diff options
Diffstat (limited to 'js/dav/dav.js')
-rw-r--r-- | js/dav/dav.js | 7323 |
1 files changed, 7323 insertions, 0 deletions
diff --git a/js/dav/dav.js b/js/dav/dav.js new file mode 100644 index 00000000..4844c34e --- /dev/null +++ b/js/dav/dav.js @@ -0,0 +1,7323 @@ +/** + * Polyfill from developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/find + */ +if (!Array.prototype.find) { + Array.prototype.find = function(predicate) { + if (this == null) { + throw new TypeError('Array.prototype.find called on null or undefined'); + } + if (typeof predicate !== 'function') { + throw new TypeError('predicate must be a function'); + } + var list = Object(this); + var length = list.length >>> 0; + var thisArg = arguments[1]; + var value; + + for (var i = 0; i < length; i++) { + value = list[i]; + if (predicate.call(thisArg, value, i, list)) { + return value; + } + } + return undefined; + }; +} +/** + * Polyfill from developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign + */ +if (!Object.assign) { + Object.defineProperty(Object, 'assign', { + enumerable: false, + configurable: true, + writable: true, + value: function(target, firstSource) { + 'use strict'; + if (target === undefined || target === null) { + throw new TypeError('Cannot convert first argument to object'); + } + + var to = Object(target); + for (var i = 1; i < arguments.length; i++) { + var nextSource = arguments[i]; + if (nextSource === undefined || nextSource === null) { + continue; + } + nextSource = Object(nextSource); + + var keysArray = Object.keys(Object(nextSource)); + for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) { + var nextKey = keysArray[nextIndex]; + var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey); + if (desc !== undefined && desc.enumerable) { + to[nextKey] = nextSource[nextKey]; + } + } + } + return to; + } + }); +} +/** + * Copyright (c) 2014, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * https://raw.github.com/facebook/regenerator/master/LICENSE file. An + * additional grant of patent rights can be found in the PATENTS file in + * the same directory. + */ + +!(function(global) { + "use strict"; + + var hasOwn = Object.prototype.hasOwnProperty; + var undefined; // More compressible than void 0. + var iteratorSymbol = + typeof Symbol === "function" && Symbol.iterator || "@@iterator"; + + var inModule = typeof module === "object"; + var runtime = global.regeneratorRuntime; + if (runtime) { + if (inModule) { + // If regeneratorRuntime is defined globally and we're in a module, + // make the exports object identical to regeneratorRuntime. + module.exports = runtime; + } + // Don't bother evaluating the rest of this file if the runtime was + // already defined globally. + return; + } + + // Define the runtime globally (as expected by generated code) as either + // module.exports (if we're in a module) or a new, empty object. + runtime = global.regeneratorRuntime = inModule ? module.exports : {}; + + function wrap(innerFn, outerFn, self, tryLocsList) { + // If outerFn provided, then outerFn.prototype instanceof Generator. + var generator = Object.create((outerFn || Generator).prototype); + + generator._invoke = makeInvokeMethod( + innerFn, self || null, + new Context(tryLocsList || []) + ); + + return generator; + } + runtime.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() {} + + var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype; + GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; + GeneratorFunctionPrototype.constructor = GeneratorFunction; + GeneratorFunction.displayName = "GeneratorFunction"; + + runtime.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; + }; + + runtime.mark = function(genFun) { + genFun.__proto__ = GeneratorFunctionPrototype; + genFun.prototype = Object.create(Gp); + return genFun; + }; + + runtime.async = function(innerFn, outerFn, self, tryLocsList) { + return new Promise(function(resolve, reject) { + var generator = wrap(innerFn, outerFn, self, tryLocsList); + var callNext = step.bind(generator, "next"); + var callThrow = step.bind(generator, "throw"); + + function step(method, arg) { + var record = tryCatch(generator[method], generator, arg); + if (record.type === "throw") { + reject(record.arg); + return; + } + + var info = record.arg; + if (info.done) { + resolve(info.value); + } else { + Promise.resolve(info.value).then(callNext, callThrow); + } + } + + callNext(); + }); + }; + + 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) { + // Be forgiving, per 25.3.3.3.3 of the spec: + // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume + return doneResult(); + } + + while (true) { + var delegate = context.delegate; + if (delegate) { + if (method === "return" || + (method === "throw" && delegate.iterator[method] === undefined)) { + // A return or throw (when the delegate iterator has no throw + // method) always terminates the yield* loop. + context.delegate = null; + + // If the delegate iterator has a return method, give it a + // chance to clean up. + var returnMethod = delegate.iterator["return"]; + if (returnMethod) { + var record = tryCatch(returnMethod, delegate.iterator, arg); + if (record.type === "throw") { + // If the return method threw an exception, let that + // exception prevail over the original return or throw. + method = "throw"; + arg = record.arg; + continue; + } + } + + if (method === "return") { + // Continue with the outer return, now that the delegate + // iterator has been terminated. + continue; + } + } + + var record = tryCatch( + delegate.iterator[method], + delegate.iterator, + arg + ); + + if (record.type === "throw") { + context.delegate = null; + + // Like returning generator.throw(uncaught), but without the + // overhead of an extra function call. + method = "throw"; + arg = record.arg; + continue; + } + + // Delegate generator ran and handled its own exceptions so + // regardless of what the method was, we continue as if it is + // "next" with an undefined arg. + method = "next"; + arg = undefined; + + var info = record.arg; + if (info.done) { + context[delegate.resultName] = info.value; + context.next = delegate.nextLoc; + } else { + state = GenStateSuspendedYield; + return info; + } + + context.delegate = null; + } + + if (method === "next") { + if (state === GenStateSuspendedYield) { + context.sent = arg; + } else { + delete context.sent; + } + + } else if (method === "throw") { + if (state === GenStateSuspendedStart) { + state = GenStateCompleted; + throw arg; + } + + if (context.dispatchException(arg)) { + // If the dispatched exception was caught by a catch block, + // then let that catch block handle the exception normally. + method = "next"; + arg = undefined; + } + + } else if (method === "return") { + context.abrupt("return", 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; + + var info = { + value: record.arg, + done: context.done + }; + + if (record.arg === ContinueSentinel) { + if (context.delegate && method === "next") { + // Deliberately forget the last sent value so that we don't + // accidentally pass it on to the delegate. + arg = undefined; + } + } else { + return info; + } + + } else if (record.type === "throw") { + state = GenStateCompleted; + // Dispatch the exception by looping back around to the + // context.dispatchException(arg) call above. + method = "throw"; + arg = record.arg; + } + } + }; + } + + function defineGeneratorMethod(method) { + Gp[method] = function(arg) { + return this._invoke(method, arg); + }; + } + defineGeneratorMethod("next"); + defineGeneratorMethod("throw"); + defineGeneratorMethod("return"); + + 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(); + } + + runtime.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; + next.done = true; + + return next; + }; + + return next.next = next; + } + } + + // Return an iterator with no values. + return { next: doneResult }; + } + runtime.values = values; + + function doneResult() { + return { value: undefined, done: true }; + } + + Context.prototype = { + constructor: Context, + + reset: function() { + this.prev = 0; + this.next = 0; + this.sent = undefined; + this.done = false; + this.delegate = null; + + this.tryEntries.forEach(resetTryEntry); + + // Pre-initialize at least 20 temporary variables to enable hidden + // class optimizations for simple generators. + for (var tempIndex = 0, tempName; + hasOwn.call(this, tempName = "t" + tempIndex) || tempIndex < 20; + ++tempIndex) { + this[tempName] = null; + } + }, + + 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; + 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.next = finallyEntry.finallyLoc; + } else { + this.complete(record); + } + + return ContinueSentinel; + }, + + 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 = record.arg; + this.next = "end"; + } else if (record.type === "normal" && afterLoc) { + this.next = afterLoc; + } + }, + + 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 + }; + + return ContinueSentinel; + } + }; +})( + // Among the various tricks for obtaining a reference to the global + // object, this seems to be the most reliable technique that does not + // use indirect eval (which violates Content Security Policy). + typeof global === "object" ? global : + typeof window === "object" ? window : + typeof self === "object" ? self : this +); +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.dav = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ +'use strict'; + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + +var _co = require('co'); + +var _co2 = _interopRequireDefault(_co); + +var _url = require('url'); + +var _url2 = _interopRequireDefault(_url); + +var _calendars = require('./calendars'); + +var _contacts = require('./contacts'); + +var _fuzzy_url_equals = require('./fuzzy_url_equals'); + +var _fuzzy_url_equals2 = _interopRequireDefault(_fuzzy_url_equals); + +var _model = require('./model'); + +var _namespace = require('./namespace'); + +var ns = _interopRequireWildcard(_namespace); + +var _request = require('./request'); + +var request = _interopRequireWildcard(_request); + +var debug = require('./debug')('dav:accounts'); + +var defaults = { + accountType: 'caldav', + loadCollections: true, + loadObjects: false +}; + +/** + * rfc 6764. + * + * @param {dav.Account} account to find root url for. + */ +var serviceDiscovery = _co2['default'].wrap(regeneratorRuntime.mark(function callee$0$0(account, options) { + var endpoint, uri, req, xhr, _location; + + return regeneratorRuntime.wrap(function callee$0$0$(context$1$0) { + while (1) switch (context$1$0.prev = context$1$0.next) { + case 0: + debug('Attempt service discovery.'); + + endpoint = _url2['default'].parse(account.server); + + endpoint.protocol = endpoint.protocol || 'http'; // TODO(gareth) https? + + uri = _url2['default'].format({ + protocol: endpoint.protocol, + host: endpoint.host, + pathname: '/.well-known/' + options.accountType + }); + req = request.basic({ method: 'GET' }); + context$1$0.prev = 5; + context$1$0.next = 8; + return options.xhr.send(req, uri, { sandbox: options.sandbox }); + + case 8: + xhr = context$1$0.sent; + + if (!(xhr.status >= 300 && xhr.status < 400)) { + context$1$0.next = 14; + break; + } + + _location = xhr.getResponseHeader('Location'); + + if (!(typeof _location === 'string' && _location.length)) { + context$1$0.next = 14; + break; + } + + debug('Discovery redirected to ' + _location); + return context$1$0.abrupt('return', _url2['default'].format({ + protocol: endpoint.protocol, + host: endpoint.host, + pathname: _location + })); + + case 14: + context$1$0.next = 19; + break; + + case 16: + context$1$0.prev = 16; + context$1$0.t0 = context$1$0['catch'](5); + + debug('Discovery failed... failover to the provided url'); + + case 19: + return context$1$0.abrupt('return', endpoint.href); + + case 20: + case 'end': + return context$1$0.stop(); + } + }, callee$0$0, this, [[5, 16]]); +})); + +/** + * rfc 5397. + * + * @param {dav.Account} account to get principal url for. + */ +var principalUrl = _co2['default'].wrap(regeneratorRuntime.mark(function callee$0$0(account, options) { + var req, res, container; + return regeneratorRuntime.wrap(function callee$0$0$(context$1$0) { + while (1) switch (context$1$0.prev = context$1$0.next) { + case 0: + debug('Fetch principal url from context path ' + account.rootUrl + '.'); + req = request.propfind({ + props: [{ name: 'current-user-principal', namespace: ns.DAV }], + depth: 0, + mergeResponses: true + }); + context$1$0.next = 4; + return options.xhr.send(req, account.rootUrl, { + sandbox: options.sandbox + }); + + case 4: + res = context$1$0.sent; + container = res.props; + + debug('Received principal: ' + container.currentUserPrincipal); + return context$1$0.abrupt('return', _url2['default'].resolve(account.rootUrl, container.currentUserPrincipal)); + + case 8: + case 'end': + return context$1$0.stop(); + } + }, callee$0$0, this); +})); + +/** + * @param {dav.Account} account to get home url for. + */ +var homeUrl = _co2['default'].wrap(regeneratorRuntime.mark(function callee$0$0(account, options) { + var prop, req, responses, response, container, href; + return regeneratorRuntime.wrap(function callee$0$0$(context$1$0) { + while (1) switch (context$1$0.prev = context$1$0.next) { + case 0: + debug('Fetch home url from principal url ' + account.principalUrl + '.'); + prop = undefined; + + if (options.accountType === 'caldav') { + prop = { name: 'calendar-home-set', namespace: ns.CALDAV }; + } else if (options.accountType === 'carddav') { + prop = { name: 'addressbook-home-set', namespace: ns.CARDDAV }; + } + + req = request.propfind({ props: [prop] }); + context$1$0.next = 6; + return options.xhr.send(req, account.principalUrl, { + sandbox: options.sandbox + }); + + case 6: + responses = context$1$0.sent; + response = responses.find(function (response) { + return (0, _fuzzy_url_equals2['default'])(account.principalUrl, response.href); + }); + container = response.props; + href = undefined; + + if (options.accountType === 'caldav') { + debug('Received home: ' + container.calendarHomeSet); + href = container.calendarHomeSet; + } else if (options.accountType === 'carddav') { + debug('Received home: ' + container.addressbookHomeSet); + href = container.addressbookHomeSet; + } + + return context$1$0.abrupt('return', _url2['default'].resolve(account.rootUrl, href)); + + case 12: + case 'end': + return context$1$0.stop(); + } + }, callee$0$0, this); +})); + +/** + * Options: + * + * (String) accountType - one of 'caldav' or 'carddav'. Defaults to 'caldav'. + * (Array.<Object>) filters - list of caldav filters to send with request. + * (Boolean) loadCollections - whether or not to load dav collections. + * (Boolean) loadObjects - whether or not to load dav objects. + * (dav.Sandbox) sandbox - optional request sandbox. + * (String) server - some url for server (needn't be base url). + * (String) timezone - VTIMEZONE calendar object. + * (dav.Transport) xhr - request sender. + * + * @return {Promise} a promise that will resolve with a dav.Account object. + */ +exports.createAccount = _co2['default'].wrap(regeneratorRuntime.mark(function callee$0$0(options) { + var account, key, loadCollections, loadObjects, collections; + return regeneratorRuntime.wrap(function callee$0$0$(context$1$0) { + while (1) switch (context$1$0.prev = context$1$0.next) { + case 0: + options = Object.assign({}, defaults, options); + if (typeof options.loadObjects !== 'boolean') { + options.loadObjects = options.loadCollections; + } + + account = new _model.Account({ + server: options.server, + credentials: options.xhr.credentials + }); + context$1$0.next = 5; + return serviceDiscovery(account, options); + + case 5: + account.rootUrl = context$1$0.sent; + context$1$0.next = 8; + return principalUrl(account, options); + + case 8: + account.principalUrl = context$1$0.sent; + context$1$0.next = 11; + return homeUrl(account, options); + + case 11: + account.homeUrl = context$1$0.sent; + + if (options.loadCollections) { + context$1$0.next = 14; + break; + } + + return context$1$0.abrupt('return', account); + + case 14: + key = undefined, loadCollections = undefined, loadObjects = undefined; + + if (options.accountType === 'caldav') { + key = 'calendars'; + loadCollections = _calendars.listCalendars; + loadObjects = _calendars.listCalendarObjects; + } else if (options.accountType === 'carddav') { + key = 'addressBooks'; + loadCollections = _contacts.listAddressBooks; + loadObjects = _contacts.listVCards; + } + + context$1$0.next = 18; + return loadCollections(account, options); + + case 18: + collections = context$1$0.sent; + + account[key] = collections; + + if (options.loadObjects) { + context$1$0.next = 22; + break; + } + + return context$1$0.abrupt('return', account); + + case 22: + context$1$0.next = 24; + return collections.map(_co2['default'].wrap(regeneratorRuntime.mark(function callee$1$0(collection) { + return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) { + while (1) switch (context$2$0.prev = context$2$0.next) { + case 0: + context$2$0.prev = 0; + context$2$0.next = 3; + return loadObjects(collection, options); + + case 3: + collection.objects = context$2$0.sent; + context$2$0.next = 9; + break; + + case 6: + context$2$0.prev = 6; + context$2$0.t0 = context$2$0['catch'](0); + + collection.error = context$2$0.t0; + + case 9: + case 'end': + return context$2$0.stop(); + } + }, callee$1$0, this, [[0, 6]]); + }))); + + case 24: + + account[key] = account[key].filter(function (collection) { + return !collection.error; + }); + + return context$1$0.abrupt('return', account); + + case 26: + case 'end': + return context$1$0.stop(); + } + }, callee$0$0, this); +})); + +// http redirect. +},{"./calendars":2,"./contacts":5,"./debug":6,"./fuzzy_url_equals":7,"./model":9,"./namespace":10,"./request":12,"co":26,"url":31}],2:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +ex |