summaryrefslogtreecommitdiffstats
path: root/js/dav/dav.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/dav/dav.js')
-rw-r--r--js/dav/dav.js7323
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
+});
+exports.createCalendarObject = createCalendarObject;
+exports.updateCalendarObject = updateCalendarObject;
+exports.deleteCalendarObject = deleteCalendarObject;
+exports.syncCalendar = syncCalendar;
+
+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 _fuzzy_url_equals = require('