From 0e375aaee0128e7fae34afff2ce66b3fb9bc7d39 Mon Sep 17 00:00:00 2001
From: MeowcaTheoRange <me@abtmtr.link>
Date: Tue, 28 May 2024 22:33:37 -0500
Subject: [PATCH] Get everything in place

---
 .gitignore                 |    1 +
 assets/scripts/script.js   |    0
 assets/styles/styles.css   |    0
 modules/extern/ical_moz.js | 9534 ++++++++++++++++++++++++++++++++++++
 modules/index.js           |   21 +
 nodemon.json               |    3 +
 package-lock.json          | 1040 ++++
 package.json               |   17 +
 pages/index.html           |   26 +
 scripts/server.js          |    0
 10 files changed, 10642 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 assets/scripts/script.js
 create mode 100644 assets/styles/styles.css
 create mode 100644 modules/extern/ical_moz.js
 create mode 100644 modules/index.js
 create mode 100644 nodemon.json
 create mode 100644 package-lock.json
 create mode 100644 package.json
 create mode 100644 pages/index.html
 create mode 100644 scripts/server.js

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..b512c09
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+node_modules
\ No newline at end of file
diff --git a/assets/scripts/script.js b/assets/scripts/script.js
new file mode 100644
index 0000000..e69de29
diff --git a/assets/styles/styles.css b/assets/styles/styles.css
new file mode 100644
index 0000000..e69de29
diff --git a/modules/extern/ical_moz.js b/modules/extern/ical_moz.js
new file mode 100644
index 0000000..c75ed9b
--- /dev/null
+++ b/modules/extern/ical_moz.js
@@ -0,0 +1,9534 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2021 */
+
+/* jshint ignore:start */
+export var ICAL;
+(function () {
+    /* istanbul ignore next */
+    if (typeof module === 'object') {
+        // CommonJS, where exports may be different each time.
+        ICAL = module.exports;
+    } else if (typeof HTMLScriptElement !== 'undefined' && 'noModule' in HTMLScriptElement.prototype) {
+        // Until we use ES6 exports, using <script type="module"> we define ICAL on the window global.
+        window.ICAL = ICAL = {};
+    } else if (typeof ICAL !== 'object') {
+        ICAL = {};
+    }
+})();
+/* jshint ignore:end */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+/**
+ * The number of characters before iCalendar line folding should occur
+ * @type {Number}
+ * @default 75
+ */
+ICAL.foldLength = 75;
+
+
+/**
+ * The character(s) to be used for a newline. The default value is provided by
+ * rfc5545.
+ * @type {String}
+ * @default "\r\n"
+ */
+ICAL.newLineChar = '\r\n';
+
+
+/**
+ * Helper functions used in various places within ical.js
+ * @namespace
+ */
+ICAL.helpers = {
+    /**
+     * Compiles a list of all referenced TZIDs in all subcomponents and
+     * removes any extra VTIMEZONE subcomponents. In addition, if any TZIDs
+     * are referenced by a component, but a VTIMEZONE does not exist,
+     * an attempt will be made to generate a VTIMEZONE using ICAL.TimezoneService.
+     *
+     * @param {ICAL.Component} vcal     The top-level VCALENDAR component.
+     * @return {ICAL.Component}         The ICAL.Component that was passed in.
+     */
+    updateTimezones: function (vcal) {
+        var allsubs, properties, vtimezones, reqTzid, i, tzid;
+
+        if (!vcal || vcal.name !== "vcalendar") {
+            //not a top-level vcalendar component
+            return vcal;
+        }
+
+        //Store vtimezone subcomponents in an object reference by tzid.
+        //Store properties from everything else in another array
+        allsubs = vcal.getAllSubcomponents();
+        properties = [];
+        vtimezones = {};
+        for (i = 0; i < allsubs.length; i++) {
+            if (allsubs[i].name === "vtimezone") {
+                tzid = allsubs[i].getFirstProperty("tzid").getFirstValue();
+                vtimezones[tzid] = allsubs[i];
+            } else {
+                properties = properties.concat(allsubs[i].getAllProperties());
+            }
+        }
+
+        //create an object with one entry for each required tz
+        reqTzid = {};
+        for (i = 0; i < properties.length; i++) {
+            if ((tzid = properties[i].getParameter("tzid"))) {
+                reqTzid[tzid] = true;
+            }
+        }
+
+        //delete any vtimezones that are not on the reqTzid list.
+        for (i in vtimezones) {
+            if (vtimezones.hasOwnProperty(i) && !reqTzid[i]) {
+                vcal.removeSubcomponent(vtimezones[i]);
+            }
+        }
+
+        //create any missing, but registered timezones
+        for (i in reqTzid) {
+            if (
+                reqTzid.hasOwnProperty(i) &&
+                !vtimezones[i] &&
+                ICAL.TimezoneService.has(i)
+            ) {
+                vcal.addSubcomponent(ICAL.TimezoneService.get(i).component);
+            }
+        }
+
+        return vcal;
+    },
+
+    /**
+     * Checks if the given type is of the number type and also NaN.
+     *
+     * @param {Number} number     The number to check
+     * @return {Boolean}          True, if the number is strictly NaN
+     */
+    isStrictlyNaN: function (number) {
+        return typeof (number) === 'number' && isNaN(number);
+    },
+
+    /**
+     * Parses a string value that is expected to be an integer, when the valid is
+     * not an integer throws a decoration error.
+     *
+     * @param {String} string     Raw string input
+     * @return {Number}           Parsed integer
+     */
+    strictParseInt: function (string) {
+        var result = parseInt(string, 10);
+
+        if (ICAL.helpers.isStrictlyNaN(result)) {
+            throw new Error(
+                'Could not extract integer from "' + string + '"'
+            );
+        }
+
+        return result;
+    },
+
+    /**
+     * Creates or returns a class instance of a given type with the initialization
+     * data if the data is not already an instance of the given type.
+     *
+     * @example
+     * var time = new ICAL.Time(...);
+     * var result = ICAL.helpers.formatClassType(time, ICAL.Time);
+     *
+     * (result instanceof ICAL.Time)
+     * // => true
+     *
+     * result = ICAL.helpers.formatClassType({}, ICAL.Time);
+     * (result isntanceof ICAL.Time)
+     * // => true
+     *
+     *
+     * @param {Object} data       object initialization data
+     * @param {Object} type       object type (like ICAL.Time)
+     * @return {?}                An instance of the found type.
+     */
+    formatClassType: function formatClassType(data, type) {
+        if (typeof (data) === 'undefined') {
+            return undefined;
+        }
+
+        if (data instanceof type) {
+            return data;
+        }
+        return new type(data);
+    },
+
+    /**
+     * Identical to indexOf but will only match values when they are not preceded
+     * by a backslash character.
+     *
+     * @param {String} buffer         String to search
+     * @param {String} search         Value to look for
+     * @param {Number} pos            Start position
+     * @return {Number}               The position, or -1 if not found
+     */
+    unescapedIndexOf: function (buffer, search, pos) {
+        while ((pos = buffer.indexOf(search, pos)) !== -1) {
+            if (pos > 0 && buffer[pos - 1] === '\\') {
+                pos += 1;
+            } else {
+                return pos;
+            }
+        }
+        return -1;
+    },
+
+    /**
+     * Find the index for insertion using binary search.
+     *
+     * @param {Array} list            The list to search
+     * @param {?} seekVal             The value to insert
+     * @param {function(?,?)} cmpfunc The comparison func, that can
+     *                                  compare two seekVals
+     * @return {Number}               The insert position
+     */
+    binsearchInsert: function (list, seekVal, cmpfunc) {
+        if (!list.length)
+            return 0;
+
+        var low = 0, high = list.length - 1,
+            mid, cmpval;
+
+        while (low <= high) {
+            mid = low + Math.floor((high - low) / 2);
+            cmpval = cmpfunc(seekVal, list[mid]);
+
+            if (cmpval < 0)
+                high = mid - 1;
+            else if (cmpval > 0)
+                low = mid + 1;
+            else
+                break;
+        }
+
+        if (cmpval < 0)
+            return mid; // insertion is displacing, so use mid outright.
+        else if (cmpval > 0)
+            return mid + 1;
+        else
+            return mid;
+    },
+
+    /**
+     * Convenience function for debug output
+     * @private
+     */
+    dumpn: /* istanbul ignore next */ function () {
+        if (!ICAL.debug) {
+            return;
+        }
+
+        if (typeof (console) !== 'undefined' && 'log' in console) {
+            ICAL.helpers.dumpn = function consoleDumpn(input) {
+                console.log(input);
+            };
+        } else {
+            ICAL.helpers.dumpn = function geckoDumpn(input) {
+                dump(input + '\n');
+            };
+        }
+
+        ICAL.helpers.dumpn(arguments[0]);
+    },
+
+    /**
+     * Clone the passed object or primitive. By default a shallow clone will be
+     * executed.
+     *
+     * @param {*} aSrc            The thing to clone
+     * @param {Boolean=} aDeep    If true, a deep clone will be performed
+     * @return {*}                The copy of the thing
+     */
+    clone: function (aSrc, aDeep) {
+        if (!aSrc || typeof aSrc != "object") {
+            return aSrc;
+        } else if (aSrc instanceof Date) {
+            return new Date(aSrc.getTime());
+        } else if ("clone" in aSrc) {
+            return aSrc.clone();
+        } else if (Array.isArray(aSrc)) {
+            var arr = [];
+            for (var i = 0; i < aSrc.length; i++) {
+                arr.push(aDeep ? ICAL.helpers.clone(aSrc[i], true) : aSrc[i]);
+            }
+            return arr;
+        } else {
+            var obj = {};
+            for (var name in aSrc) {
+                // uses prototype method to allow use of Object.create(null);
+                /* istanbul ignore else */
+                if (Object.prototype.hasOwnProperty.call(aSrc, name)) {
+                    if (aDeep) {
+                        obj[name] = ICAL.helpers.clone(aSrc[name], true);
+                    } else {
+                        obj[name] = aSrc[name];
+                    }
+                }
+            }
+            return obj;
+        }
+    },
+
+    /**
+     * Performs iCalendar line folding. A line ending character is inserted and
+     * the next line begins with a whitespace.
+     *
+     * @example
+     * SUMMARY:This line will be fold
+     *  ed right in the middle of a word.
+     *
+     * @param {String} aLine      The line to fold
+     * @return {String}           The folded line
+     */
+    foldline: function foldline(aLine) {
+        var result = "";
+        var line = aLine || "", pos = 0, line_length = 0;
+        //pos counts position in line for the UTF-16 presentation
+        //line_length counts the bytes for the UTF-8 presentation
+        while (line.length) {
+            var cp = line.codePointAt(pos);
+            if (cp < 128) ++line_length;
+            else if (cp < 2048) line_length += 2;//needs 2 UTF-8 bytes
+            else if (cp < 65536) line_length += 3;
+            else line_length += 4; //cp is less than 1114112
+            if (line_length < ICAL.foldLength + 1)
+                pos += cp > 65535 ? 2 : 1;
+            else {
+                result += ICAL.newLineChar + " " + line.substring(0, pos);
+                line = line.substring(pos);
+                pos = line_length = 0;
+            }
+        }
+        return result.substr(ICAL.newLineChar.length + 1);
+    },
+
+    /**
+     * Pads the given string or number with zeros so it will have at least two
+     * characters.
+     *
+     * @param {String|Number} data    The string or number to pad
+     * @return {String}               The number padded as a string
+     */
+    pad2: function pad(data) {
+        if (typeof (data) !== 'string') {
+            // handle fractions.
+            if (typeof (data) === 'number') {
+                data = parseInt(data);
+            }
+            data = String(data);
+        }
+
+        var len = data.length;
+
+        switch (len) {
+            case 0:
+                return '00';
+            case 1:
+                return '0' + data;
+            default:
+                return data;
+        }
+    },
+
+    /**
+     * Truncates the given number, correctly handling negative numbers.
+     *
+     * @param {Number} number     The number to truncate
+     * @return {Number}           The truncated number
+     */
+    trunc: function trunc(number) {
+        return (number < 0 ? Math.ceil(number) : Math.floor(number));
+    },
+
+    /**
+     * Poor-man's cross-browser inheritance for JavaScript. Doesn't support all
+     * the features, but enough for our usage.
+     *
+     * @param {Function} base     The base class constructor function.
+     * @param {Function} child    The child class constructor function.
+     * @param {Object} extra      Extends the prototype with extra properties
+     *                              and methods
+     */
+    inherits: function (base, child, extra) {
+        function F() { }
+        F.prototype = base.prototype;
+        child.prototype = new F();
+
+        if (extra) {
+            ICAL.helpers.extend(extra, child.prototype);
+        }
+    },
+
+    /**
+     * Poor-man's cross-browser object extension. Doesn't support all the
+     * features, but enough for our usage. Note that the target's properties are
+     * not overwritten with the source properties.
+     *
+     * @example
+     * var child = ICAL.helpers.extend(parent, {
+     *   "bar": 123
+     * });
+     *
+     * @param {Object} source     The object to extend
+     * @param {Object} target     The object to extend with
+     * @return {Object}           Returns the target.
+     */
+    extend: function (source, target) {
+        for (var key in source) {
+            var descr = Object.getOwnPropertyDescriptor(source, key);
+            if (descr && !Object.getOwnPropertyDescriptor(target, key)) {
+                Object.defineProperty(target, key, descr);
+            }
+        }
+        return target;
+    }
+};
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+/** @namespace ICAL */
+
+
+/**
+ * This symbol is further described later on
+ * @ignore
+ */
+ICAL.design = (function () {
+    'use strict';
+
+    var FROM_ICAL_NEWLINE = /\\\\|\\;|\\,|\\[Nn]/g;
+    var TO_ICAL_NEWLINE = /\\|;|,|\n/g;
+    var FROM_VCARD_NEWLINE = /\\\\|\\,|\\[Nn]/g;
+    var TO_VCARD_NEWLINE = /\\|,|\n/g;
+
+    function createTextType(fromNewline, toNewline) {
+        var result = {
+            matches: /.*/,
+
+            fromICAL: function (aValue, structuredEscape) {
+                return replaceNewline(aValue, fromNewline, structuredEscape);
+            },
+
+            toICAL: function (aValue, structuredEscape) {
+                var regEx = toNewline;
+                if (structuredEscape)
+                    regEx = new RegExp(regEx.source + '|' + structuredEscape);
+                return aValue.replace(regEx, function (str) {
+                    switch (str) {
+                        case "\\":
+                            return "\\\\";
+                        case ";":
+                            return "\\;";
+                        case ",":
+                            return "\\,";
+                        case "\n":
+                            return "\\n";
+                        /* istanbul ignore next */
+                        default:
+                            return str;
+                    }
+                });
+            }
+        };
+        return result;
+    }
+
+    // default types used multiple times
+    var DEFAULT_TYPE_TEXT = { defaultType: "text" };
+    var DEFAULT_TYPE_TEXT_MULTI = { defaultType: "text", multiValue: "," };
+    var DEFAULT_TYPE_TEXT_STRUCTURED = { defaultType: "text", structuredValue: ";" };
+    var DEFAULT_TYPE_INTEGER = { defaultType: "integer" };
+    var DEFAULT_TYPE_DATETIME_DATE = { defaultType: "date-time", allowedTypes: ["date-time", "date"] };
+    var DEFAULT_TYPE_DATETIME = { defaultType: "date-time" };
+    var DEFAULT_TYPE_URI = { defaultType: "uri" };
+    var DEFAULT_TYPE_UTCOFFSET = { defaultType: "utc-offset" };
+    var DEFAULT_TYPE_RECUR = { defaultType: "recur" };
+    var DEFAULT_TYPE_DATE_ANDOR_TIME = { defaultType: "date-and-or-time", allowedTypes: ["date-time", "date", "text"] };
+
+    function replaceNewlineReplace(string) {
+        switch (string) {
+            case "\\\\":
+                return "\\";
+            case "\\;":
+                return ";";
+            case "\\,":
+                return ",";
+            case "\\n":
+            case "\\N":
+                return "\n";
+            /* istanbul ignore next */
+            default:
+                return string;
+        }
+    }
+
+    function replaceNewline(value, newline, structuredEscape) {
+        // avoid regex when possible.
+        if (value.indexOf('\\') === -1) {
+            return value;
+        }
+        if (structuredEscape)
+            newline = new RegExp(newline.source + '|\\\\' + structuredEscape);
+        return value.replace(newline, replaceNewlineReplace);
+    }
+
+    var commonProperties = {
+        "categories": DEFAULT_TYPE_TEXT_MULTI,
+        "url": DEFAULT_TYPE_URI,
+        "version": DEFAULT_TYPE_TEXT,
+        "uid": DEFAULT_TYPE_TEXT
+    };
+
+    var commonValues = {
+        "boolean": {
+            values: ["TRUE", "FALSE"],
+
+            fromICAL: function (aValue) {
+                switch (aValue) {
+                    case 'TRUE':
+                        return true;
+                    case 'FALSE':
+                        return false;
+                    default:
+                        //TODO: parser warning
+                        return false;
+                }
+            },
+
+            toICAL: function (aValue) {
+                if (aValue) {
+                    return 'TRUE';
+                }
+                return 'FALSE';
+            }
+
+        },
+        float: {
+            matches: /^[+-]?\d+\.\d+$/,
+
+            fromICAL: function (aValue) {
+                var parsed = parseFloat(aValue);
+                if (ICAL.helpers.isStrictlyNaN(parsed)) {
+                    // TODO: parser warning
+                    return 0.0;
+                }
+                return parsed;
+            },
+
+            toICAL: function (aValue) {
+                return String(aValue);
+            }
+        },
+        integer: {
+            fromICAL: function (aValue) {
+                var parsed = parseInt(aValue);
+                if (ICAL.helpers.isStrictlyNaN(parsed)) {
+                    return 0;
+                }
+                return parsed;
+            },
+
+            toICAL: function (aValue) {
+                return String(aValue);
+            }
+        },
+        "utc-offset": {
+            toICAL: function (aValue) {
+                if (aValue.length < 7) {
+                    // no seconds
+                    // -0500
+                    return aValue.substr(0, 3) +
+                        aValue.substr(4, 2);
+                } else {
+                    // seconds
+                    // -050000
+                    return aValue.substr(0, 3) +
+                        aValue.substr(4, 2) +
+                        aValue.substr(7, 2);
+                }
+            },
+
+            fromICAL: function (aValue) {
+                if (aValue.length < 6) {
+                    // no seconds
+                    // -05:00
+                    return aValue.substr(0, 3) + ':' +
+                        aValue.substr(3, 2);
+                } else {
+                    // seconds
+                    // -05:00:00
+                    return aValue.substr(0, 3) + ':' +
+                        aValue.substr(3, 2) + ':' +
+                        aValue.substr(5, 2);
+                }
+            },
+
+            decorate: function (aValue) {
+                return ICAL.UtcOffset.fromString(aValue);
+            },
+
+            undecorate: function (aValue) {
+                return aValue.toString();
+            }
+        }
+    };
+
+    var icalParams = {
+        // Although the syntax is DQUOTE uri DQUOTE, I don't think we should
+        // enfoce anything aside from it being a valid content line.
+        //
+        // At least some params require - if multi values are used - DQUOTEs
+        // for each of its values - e.g. delegated-from="uri1","uri2"
+        // To indicate this, I introduced the new k/v pair
+        // multiValueSeparateDQuote: true
+        //
+        // "ALTREP": { ... },
+
+        // CN just wants a param-value
+        // "CN": { ... }
+
+        "cutype": {
+            values: ["INDIVIDUAL", "GROUP", "RESOURCE", "ROOM", "UNKNOWN"],
+            allowXName: true,
+            allowIanaToken: true
+        },
+
+        "delegated-from": {
+            valueType: "cal-address",
+            multiValue: ",",
+            multiValueSeparateDQuote: true
+        },
+        "delegated-to": {
+            valueType: "cal-address",
+            multiValue: ",",
+            multiValueSeparateDQuote: true
+        },
+        // "DIR": { ... }, // See ALTREP
+        "encoding": {
+            values: ["8BIT", "BASE64"]
+        },
+        // "FMTTYPE": { ... }, // See ALTREP
+        "fbtype": {
+            values: ["FREE", "BUSY", "BUSY-UNAVAILABLE", "BUSY-TENTATIVE"],
+            allowXName: true,
+            allowIanaToken: true
+        },
+        // "LANGUAGE": { ... }, // See ALTREP
+        "member": {
+            valueType: "cal-address",
+            multiValue: ",",
+            multiValueSeparateDQuote: true
+        },
+        "partstat": {
+            // TODO These values are actually different per-component
+            values: ["NEEDS-ACTION", "ACCEPTED", "DECLINED", "TENTATIVE",
+                "DELEGATED", "COMPLETED", "IN-PROCESS"],
+            allowXName: true,
+            allowIanaToken: true
+        },
+        "range": {
+            values: ["THISANDFUTURE"]
+        },
+        "related": {
+            values: ["START", "END"]
+        },
+        "reltype": {
+            values: ["PARENT", "CHILD", "SIBLING"],
+            allowXName: true,
+            allowIanaToken: true
+        },
+        "role": {
+            values: ["REQ-PARTICIPANT", "CHAIR",
+                "OPT-PARTICIPANT", "NON-PARTICIPANT"],
+            allowXName: true,
+            allowIanaToken: true
+        },
+        "rsvp": {
+            values: ["TRUE", "FALSE"]
+        },
+        "sent-by": {
+            valueType: "cal-address"
+        },
+        "tzid": {
+            matches: /^\//
+        },
+        "value": {
+            // since the value here is a 'type' lowercase is used.
+            values: ["binary", "boolean", "cal-address", "date", "date-time",
+                "duration", "float", "integer", "period", "recur", "text",
+                "time", "uri", "utc-offset"],
+            allowXName: true,
+            allowIanaToken: true
+        }
+    };
+
+    // When adding a value here, be sure to add it to the parameter types!
+    var icalValues = ICAL.helpers.extend(commonValues, {
+        text: createTextType(FROM_ICAL_NEWLINE, TO_ICAL_NEWLINE),
+
+        uri: {
+            // TODO
+            /* ... */
+        },
+
+        "binary": {
+            decorate: function (aString) {
+                return ICAL.Binary.fromString(aString);
+            },
+
+            undecorate: function (aBinary) {
+                return aBinary.toString();
+            }
+        },
+        "cal-address": {
+            // needs to be an uri
+        },
+        "date": {
+            decorate: function (aValue, aProp) {
+                if (design.strict) {
+                    return ICAL.Time.fromDateString(aValue, aProp);
+                } else {
+                    return ICAL.Time.fromString(aValue, aProp);
+                }
+            },
+
+            /**
+             * undecorates a time object.
+             */
+            undecorate: function (aValue) {
+                return aValue.toString();
+            },
+
+            fromICAL: function (aValue) {
+                // from: 20120901
+                // to: 2012-09-01
+                if (!design.strict && aValue.length >= 15) {
+                    // This is probably a date-time, e.g. 20120901T130000Z
+                    return icalValues["date-time"].fromICAL(aValue);
+                } else {
+                    return aValue.substr(0, 4) + '-' +
+                        aValue.substr(4, 2) + '-' +
+                        aValue.substr(6, 2);
+                }
+            },
+
+            toICAL: function (aValue) {
+                // from: 2012-09-01
+                // to: 20120901
+                var len = aValue.length;
+
+                if (len == 10) {
+                    return aValue.substr(0, 4) +
+                        aValue.substr(5, 2) +
+                        aValue.substr(8, 2);
+                } else if (len >= 19) {
+                    return icalValues["date-time"].toICAL(aValue);
+                } else {
+                    //TODO: serialize warning?
+                    return aValue;
+                }
+
+            }
+        },
+        "date-time": {
+            fromICAL: function (aValue) {
+                // from: 20120901T130000
+                // to: 2012-09-01T13:00:00
+                if (!design.strict && aValue.length == 8) {
+                    // This is probably a date, e.g. 20120901
+                    return icalValues.date.fromICAL(aValue);
+                } else {
+                    var result = aValue.substr(0, 4) + '-' +
+                        aValue.substr(4, 2) + '-' +
+                        aValue.substr(6, 2) + 'T' +
+                        aValue.substr(9, 2) + ':' +
+                        aValue.substr(11, 2) + ':' +
+                        aValue.substr(13, 2);
+
+                    if (aValue[15] && aValue[15] === 'Z') {
+                        result += 'Z';
+                    }
+
+                    return result;
+                }
+            },
+
+            toICAL: function (aValue) {
+                // from: 2012-09-01T13:00:00
+                // to: 20120901T130000
+                var len = aValue.length;
+
+                if (len == 10 && !design.strict) {
+                    return icalValues.date.toICAL(aValue);
+                } else if (len >= 19) {
+                    var result = aValue.substr(0, 4) +
+                        aValue.substr(5, 2) +
+                        // grab the (DDTHH) segment
+                        aValue.substr(8, 5) +
+                        // MM
+                        aValue.substr(14, 2) +
+                        // SS
+                        aValue.substr(17, 2);
+
+                    if (aValue[19] && aValue[19] === 'Z') {
+                        result += 'Z';
+                    }
+                    return result;
+                } else {
+                    // TODO: error
+                    return aValue;
+                }
+            },
+
+            decorate: function (aValue, aProp) {
+                if (design.strict) {
+                    return ICAL.Time.fromDateTimeString(aValue, aProp);
+                } else {
+                    return ICAL.Time.fromString(aValue, aProp);
+                }
+            },
+
+            undecorate: function (aValue) {
+                return aValue.toString();
+            }
+        },
+        duration: {
+            decorate: function (aValue) {
+                return ICAL.Duration.fromString(aValue);
+            },
+            undecorate: function (aValue) {
+                return aValue.toString();
+            }
+        },
+        period: {
+
+            fromICAL: function (string) {
+                var parts = string.split('/');
+                parts[0] = icalValues['date-time'].fromICAL(parts[0]);
+
+                if (!ICAL.Duration.isValueString(parts[1])) {
+                    parts[1] = icalValues['date-time'].fromICAL(parts[1]);
+                }
+
+                return parts;
+            },
+
+            toICAL: function (parts) {
+                if (!design.strict && parts[0].length == 10) {
+                    parts[0] = icalValues.date.toICAL(parts[0]);
+                } else {
+                    parts[0] = icalValues['date-time'].toICAL(parts[0]);
+                }
+
+                if (!ICAL.Duration.isValueString(parts[1])) {
+                    if (!design.strict && parts[1].length == 10) {
+                        parts[1] = icalValues.date.toICAL(parts[1]);
+                    } else {
+                        parts[1] = icalValues['date-time'].toICAL(parts[1]);
+                    }
+                }
+
+                return parts.join("/");
+            },
+
+            decorate: function (aValue, aProp) {
+                return ICAL.Period.fromJSON(aValue, aProp, !design.strict);
+            },
+
+            undecorate: function (aValue) {
+                return aValue.toJSON();
+            }
+        },
+        recur: {
+            fromICAL: function (string) {
+                return ICAL.Recur._stringToData(string, true);
+            },
+
+            toICAL: function (data) {
+                var str = "";
+                for (var k in data) {
+                    /* istanbul ignore if */
+                    if (!Object.prototype.hasOwnProperty.call(data, k)) {
+                        continue;
+                    }
+                    var val = data[k];
+                    if (k == "until") {
+                        if (val.length > 10) {
+                            val = icalValues['date-time'].toICAL(val);
+                        } else {
+                            val = icalValues.date.toICAL(val);
+                        }
+                    } else if (k == "wkst") {
+                        if (typeof val === 'number') {
+                            val = ICAL.Recur.numericDayToIcalDay(val);
+                        }
+                    } else if (Array.isArray(val)) {
+                        val = val.join(",");
+                    }
+                    str += k.toUpperCase() + "=" + val + ";";
+                }
+                return str.substr(0, str.length - 1);
+            },
+
+            decorate: function decorate(aValue) {
+                return ICAL.Recur.fromData(aValue);
+            },
+
+            undecorate: function (aRecur) {
+                return aRecur.toJSON();
+            }
+        },
+
+        time: {
+            fromICAL: function (aValue) {
+                // from: MMHHSS(Z)?
+                // to: HH:MM:SS(Z)?
+                if (aValue.length < 6) {
+                    // TODO: parser exception?
+                    return aValue;
+                }
+
+                // HH::MM::SSZ?
+                var result = aValue.substr(0, 2) + ':' +
+                    aValue.substr(2, 2) + ':' +
+                    aValue.substr(4, 2);
+
+                if (aValue[6] === 'Z') {
+                    result += 'Z';
+                }
+
+                return result;
+            },
+
+            toICAL: function (aValue) {
+                // from: HH:MM:SS(Z)?
+                // to: MMHHSS(Z)?
+                if (aValue.length < 8) {
+                    //TODO: error
+                    return aValue;
+                }
+
+                var result = aValue.substr(0, 2) +
+                    aValue.substr(3, 2) +
+                    aValue.substr(6, 2);
+
+                if (aValue[8] === 'Z') {
+                    result += 'Z';
+                }
+
+                return result;
+            }
+        }
+    });
+
+    var icalProperties = ICAL.helpers.extend(commonProperties, {
+
+        "action": DEFAULT_TYPE_TEXT,
+        "attach": { defaultType: "uri" },
+        "attendee": { defaultType: "cal-address" },
+        "calscale": DEFAULT_TYPE_TEXT,
+        "class": DEFAULT_TYPE_TEXT,
+        "comment": DEFAULT_TYPE_TEXT,
+        "completed": DEFAULT_TYPE_DATETIME,
+        "contact": DEFAULT_TYPE_TEXT,
+        "created": DEFAULT_TYPE_DATETIME,
+        "description": DEFAULT_TYPE_TEXT,
+        "dtend": DEFAULT_TYPE_DATETIME_DATE,
+        "dtstamp": DEFAULT_TYPE_DATETIME,
+        "dtstart": DEFAULT_TYPE_DATETIME_DATE,
+        "due": DEFAULT_TYPE_DATETIME_DATE,
+        "duration": { defaultType: "duration" },
+        "exdate": {
+            defaultType: "date-time",
+            allowedTypes: ["date-time", "date"],
+            multiValue: ','
+        },
+        "exrule": DEFAULT_TYPE_RECUR,
+        "freebusy": { defaultType: "period", multiValue: "," },
+        "geo": { defaultType: "float", structuredValue: ";" },
+        "last-modified": DEFAULT_TYPE_DATETIME,
+        "location": DEFAULT_TYPE_TEXT,
+        "method": DEFAULT_TYPE_TEXT,
+        "organizer": { defaultType: "cal-address" },
+        "percent-complete": DEFAULT_TYPE_INTEGER,
+        "priority": DEFAULT_TYPE_INTEGER,
+        "prodid": DEFAULT_TYPE_TEXT,
+        "related-to": DEFAULT_TYPE_TEXT,
+        "repeat": DEFAULT_TYPE_INTEGER,
+        "rdate": {
+            defaultType: "date-time",
+            allowedTypes: ["date-time", "date", "period"],
+            multiValue: ',',
+            detectType: function (string) {
+                if (string.indexOf('/') !== -1) {
+                    return 'period';
+                }
+                return (string.indexOf('T') === -1) ? 'date' : 'date-time';
+            }
+        },
+        "recurrence-id": DEFAULT_TYPE_DATETIME_DATE,
+        "resources": DEFAULT_TYPE_TEXT_MULTI,
+        "request-status": DEFAULT_TYPE_TEXT_STRUCTURED,
+        "rrule": DEFAULT_TYPE_RECUR,
+        "sequence": DEFAULT_TYPE_INTEGER,
+        "status": DEFAULT_TYPE_TEXT,
+        "summary": DEFAULT_TYPE_TEXT,
+        "transp": DEFAULT_TYPE_TEXT,
+        "trigger": { defaultType: "duration", allowedTypes: ["duration", "date-time"] },
+        "tzoffsetfrom": DEFAULT_TYPE_UTCOFFSET,
+        "tzoffsetto": DEFAULT_TYPE_UTCOFFSET,
+        "tzurl": DEFAULT_TYPE_URI,
+        "tzid": DEFAULT_TYPE_TEXT,
+        "tzname": DEFAULT_TYPE_TEXT
+    });
+
+    // When adding a value here, be sure to add it to the parameter types!
+    var vcardValues = ICAL.helpers.extend(commonValues, {
+        text: createTextType(FROM_VCARD_NEWLINE, TO_VCARD_NEWLINE),
+        uri: createTextType(FROM_VCARD_NEWLINE, TO_VCARD_NEWLINE),
+
+        date: {
+            decorate: function (aValue) {
+                return ICAL.VCardTime.fromDateAndOrTimeString(aValue, "date");
+            },
+            undecorate: function (aValue) {
+                return aValue.toString();
+            },
+            fromICAL: function (aValue) {
+                if (aValue.length == 8) {
+                    return icalValues.date.fromICAL(aValue);
+                } else if (aValue[0] == '-' && aValue.length == 6) {
+                    return aValue.substr(0, 4) + '-' + aValue.substr(4);
+                } else {
+                    return aValue;
+                }
+            },
+            toICAL: function (aValue) {
+                if (aValue.length == 10) {
+                    return icalValues.date.toICAL(aValue);
+                } else if (aValue[0] == '-' && aValue.length == 7) {
+                    return aValue.substr(0, 4) + aValue.substr(5);
+                } else {
+                    return aValue;
+                }
+            }
+        },
+
+        time: {
+            decorate: function (aValue) {
+                return ICAL.VCardTime.fromDateAndOrTimeString("T" + aValue, "time");
+            },
+            undecorate: function (aValue) {
+                return aValue.toString();
+            },
+            fromICAL: function (aValue) {
+                var splitzone = vcardValues.time._splitZone(aValue, true);
+                var zone = splitzone[0], value = splitzone[1];
+
+                //console.log("SPLIT: ",splitzone);
+
+                if (value.length == 6) {
+                    value = value.substr(0, 2) + ':' +
+                        value.substr(2, 2) + ':' +
+                        value.substr(4, 2);
+                } else if (value.length == 4 && value[0] != '-') {
+                    value = value.substr(0, 2) + ':' + value.substr(2, 2);
+                } else if (value.length == 5) {
+                    value = value.substr(0, 3) + ':' + value.substr(3, 2);
+                }
+
+                if (zone.length == 5 && (zone[0] == '-' || zone[0] == '+')) {
+                    zone = zone.substr(0, 3) + ':' + zone.substr(3);
+                }
+
+                return value + zone;
+            },
+
+            toICAL: function (aValue) {
+                var splitzone = vcardValues.time._splitZone(aValue);
+                var zone = splitzone[0], value = splitzone[1];
+
+                if (value.length == 8) {
+                    value = value.substr(0, 2) +
+                        value.substr(3, 2) +
+                        value.substr(6, 2);
+                } else if (value.length == 5 && value[0] != '-') {
+                    value = value.substr(0, 2) + value.substr(3, 2);
+                } else if (value.length == 6) {
+                    value = value.substr(0, 3) + value.substr(4, 2);
+                }
+
+                if (zone.length == 6 && (zone[0] == '-' || zone[0] == '+')) {
+                    zone = zone.substr(0, 3) + zone.substr(4);
+                }
+
+                return value + zone;
+            },
+
+            _splitZone: function (aValue, isFromIcal) {
+                var lastChar = aValue.length - 1;
+                var signChar = aValue.length - (isFromIcal ? 5 : 6);
+                var sign = aValue[signChar];
+                var zone, value;
+
+                if (aValue[lastChar] == 'Z') {
+                    zone = aValue[lastChar];
+                    value = aValue.substr(0, lastChar);
+                } else if (aValue.length > 6 && (sign == '-' || sign == '+')) {
+                    zone = aValue.substr(signChar);
+                    value = aValue.substr(0, signChar);
+                } else {
+                    zone = "";
+                    value = aValue;
+                }
+
+                return [zone, value];
+            }
+        },
+
+        "date-time": {
+            decorate: function (aValue) {
+                return ICAL.VCardTime.fromDateAndOrTimeString(aValue, "date-time");
+            },
+
+            undecorate: function (aValue) {
+                return aValue.toString();
+            },
+
+            fromICAL: function (aValue) {
+                return vcardValues['date-and-or-time'].fromICAL(aValue);
+            },
+
+            toICAL: function (aValue) {
+                return vcardValues['date-and-or-time'].toICAL(aValue);
+            }
+        },
+
+        "date-and-or-time": {
+            decorate: function (aValue) {
+                return ICAL.VCardTime.fromDateAndOrTimeString(aValue, "date-and-or-time");
+            },
+
+            undecorate: function (aValue) {
+                return aValue.toString();
+            },
+
+            fromICAL: function (aValue) {
+                var parts = aValue.split('T');
+                return (parts[0] ? vcardValues.date.fromICAL(parts[0]) : '') +
+                    (parts[1] ? 'T' + vcardValues.time.fromICAL(parts[1]) : '');
+            },
+
+            toICAL: function (aValue) {
+                var parts = aValue.split('T');
+                return vcardValues.date.toICAL(parts[0]) +
+                    (parts[1] ? 'T' + vcardValues.time.toICAL(parts[1]) : '');
+
+            }
+        },
+        timestamp: icalValues['date-time'],
+        "language-tag": {
+            matches: /^[a-zA-Z0-9-]+$/ // Could go with a more strict regex here
+        }
+    });
+
+    var vcardParams = {
+        "type": {
+            valueType: "text",
+            multiValue: ","
+        },
+        "value": {
+            // since the value here is a 'type' lowercase is used.
+            values: ["text", "uri", "date", "time", "date-time", "date-and-or-time",
+                "timestamp", "boolean", "integer", "float", "utc-offset",
+                "language-tag"],
+            allowXName: true,
+            allowIanaToken: true
+        }
+    };
+
+    var vcardProperties = ICAL.helpers.extend(commonProperties, {
+        "adr": { defaultType: "text", structuredValue: ";", multiValue: "," },
+        "anniversary": DEFAULT_TYPE_DATE_ANDOR_TIME,
+        "bday": DEFAULT_TYPE_DATE_ANDOR_TIME,
+        "caladruri": DEFAULT_TYPE_URI,
+        "caluri": DEFAULT_TYPE_URI,
+        "clientpidmap": DEFAULT_TYPE_TEXT_STRUCTURED,
+        "email": DEFAULT_TYPE_TEXT,
+        "fburl": DEFAULT_TYPE_URI,
+        "fn": DEFAULT_TYPE_TEXT,
+        "gender": DEFAULT_TYPE_TEXT_STRUCTURED,
+        "geo": DEFAULT_TYPE_URI,
+        "impp": DEFAULT_TYPE_URI,
+        "key": DEFAULT_TYPE_URI,
+        "kind": DEFAULT_TYPE_TEXT,
+        "lang": { defaultType: "language-tag" },
+        "logo": DEFAULT_TYPE_URI,
+        "member": DEFAULT_TYPE_URI,
+        "n": { defaultType: "text", structuredValue: ";", multiValue: "," },
+        "nickname": DEFAULT_TYPE_TEXT_MULTI,
+        "note": DEFAULT_TYPE_TEXT,
+        "org": { defaultType: "text", structuredValue: ";" },
+        "photo": DEFAULT_TYPE_URI,
+        "related": DEFAULT_TYPE_URI,
+        "rev": { defaultType: "timestamp" },
+        "role": DEFAULT_TYPE_TEXT,
+        "sound": DEFAULT_TYPE_URI,
+        "source": DEFAULT_TYPE_URI,
+        "tel": { defaultType: "uri", allowedTypes: ["uri", "text"] },
+        "title": DEFAULT_TYPE_TEXT,
+        "tz": { defaultType: "text", allowedTypes: ["text", "utc-offset", "uri"] },
+        "xml": DEFAULT_TYPE_TEXT
+    });
+
+    var vcard3Values = ICAL.helpers.extend(commonValues, {
+        binary: icalValues.binary,
+        date: vcardValues.date,
+        "date-time": vcardValues["date-time"],
+        "phone-number": {
+            // TODO
+            /* ... */
+        },
+        uri: icalValues.uri,
+        text: icalValues.text,
+        time: icalValues.time,
+        vcard: icalValues.text,
+        "utc-offset": {
+            toICAL: function (aValue) {
+                return aValue.substr(0, 7);
+            },
+
+            fromICAL: function (aValue) {
+                return aValue.substr(0, 7);
+            },
+
+            decorate: function (aValue) {
+                return ICAL.UtcOffset.fromString(aValue);
+            },
+
+            undecorate: function (aValue) {
+                return aValue.toString();
+            }
+        }
+    });
+
+    var vcard3Params = {
+        "type": {
+            valueType: "text",
+            multiValue: ","
+        },
+        "value": {
+            // since the value here is a 'type' lowercase is used.
+            values: ["text", "uri", "date", "date-time", "phone-number", "time",
+                "boolean", "integer", "float", "utc-offset", "vcard", "binary"],
+            allowXName: true,
+            allowIanaToken: true
+        }
+    };
+
+    var vcard3Properties = ICAL.helpers.extend(commonProperties, {
+        fn: DEFAULT_TYPE_TEXT,
+        n: { defaultType: "text", structuredValue: ";", multiValue: "," },
+        nickname: DEFAULT_TYPE_TEXT_MULTI,
+        photo: { defaultType: "binary", allowedTypes: ["binary", "uri"] },
+        bday: {
+            defaultType: "date-time",
+            allowedTypes: ["date-time", "date"],
+            detectType: function (string) {
+                return (string.indexOf('T') === -1) ? 'date' : 'date-time';
+            }
+        },
+
+        adr: { defaultType: "text", structuredValue: ";", multiValue: "," },
+        label: DEFAULT_TYPE_TEXT,
+
+        tel: { defaultType: "phone-number" },
+        email: DEFAULT_TYPE_TEXT,
+        mailer: DEFAULT_TYPE_TEXT,
+
+        tz: { defaultType: "utc-offset", allowedTypes: ["utc-offset", "text"] },
+        geo: { defaultType: "float", structuredValue: ";" },
+
+        title: DEFAULT_TYPE_TEXT,
+        role: DEFAULT_TYPE_TEXT,
+        logo: { defaultType: "binary", allowedTypes: ["binary", "uri"] },
+        agent: { defaultType: "vcard", allowedTypes: ["vcard", "text", "uri"] },
+        org: DEFAULT_TYPE_TEXT_STRUCTURED,
+
+        note: DEFAULT_TYPE_TEXT_MULTI,
+        prodid: DEFAULT_TYPE_TEXT,
+        rev: {
+            defaultType: "date-time",
+            allowedTypes: ["date-time", "date"],
+            detectType: function (string) {
+                return (string.indexOf('T') === -1) ? 'date' : 'date-time';
+            }
+        },
+        "sort-string": DEFAULT_TYPE_TEXT,
+        sound: { defaultType: "binary", allowedTypes: ["binary", "uri"] },
+
+        class: DEFAULT_TYPE_TEXT,
+        key: { defaultType: "binary", allowedTypes: ["binary", "text"] }
+    });
+
+    /**
+     * iCalendar design set
+     * @type {ICAL.design.designSet}
+     */
+    var icalSet = {
+        value: icalValues,
+        param: icalParams,
+        property: icalProperties
+    };
+
+    /**
+     * vCard 4.0 design set
+     * @type {ICAL.design.designSet}
+     */
+    var vcardSet = {
+        value: vcardValues,
+        param: vcardParams,
+        property: vcardProperties
+    };
+
+    /**
+     * vCard 3.0 design set
+     * @type {ICAL.design.designSet}
+     */
+    var vcard3Set = {
+        value: vcard3Values,
+        param: vcard3Params,
+        property: vcard3Properties
+    };
+
+    /**
+     * The design data, used by the parser to determine types for properties and
+     * other metadata needed to produce correct jCard/jCal data.
+     *
+     * @alias ICAL.design
+     * @namespace
+     */
+    var design = {
+        /**
+         * A designSet describes value, parameter and property data. It is used by
+         * ther parser and stringifier in components and properties to determine they
+         * should be represented.
+         *
+         * @typedef {Object} designSet
+         * @memberOf ICAL.design
+         * @property {Object} value       Definitions for value types, keys are type names
+         * @property {Object} param       Definitions for params, keys are param names
+         * @property {Object} property    Defintions for properties, keys are property names
+         */
+
+        /**
+         * Can be set to false to make the parser more lenient.
+         */
+        strict: true,
+
+        /**
+         * The default set for new properties and components if none is specified.
+         * @type {ICAL.design.designSet}
+         */
+        defaultSet: icalSet,
+
+        /**
+         * The default type for unknown properties
+         * @type {String}
+         */
+        defaultType: 'unknown',
+
+        /**
+         * Holds the design set for known top-level components
+         *
+         * @type {Object}
+         * @property {ICAL.design.designSet} vcard       vCard VCARD
+         * @property {ICAL.design.designSet} vevent      iCalendar VEVENT
+         * @property {ICAL.design.designSet} vtodo       iCalendar VTODO
+         * @property {ICAL.design.designSet} vjournal    iCalendar VJOURNAL
+         * @property {ICAL.design.designSet} valarm      iCalendar VALARM
+         * @property {ICAL.design.designSet} vtimezone   iCalendar VTIMEZONE
+         * @property {ICAL.design.designSet} daylight    iCalendar DAYLIGHT
+         * @property {ICAL.design.designSet} standard    iCalendar STANDARD
+         *
+         * @example
+         * var propertyName = 'fn';
+         * var componentDesign = ICAL.design.components.vcard;
+         * var propertyDetails = componentDesign.property[propertyName];
+         * if (propertyDetails.defaultType == 'text') {
+         *   // Yep, sure is...
+         * }
+         */
+        components: {
+            vcard: vcardSet,
+            vcard3: vcard3Set,
+            vevent: icalSet,
+            vtodo: icalSet,
+            vjournal: icalSet,
+            valarm: icalSet,
+            vtimezone: icalSet,
+            daylight: icalSet,
+            standard: icalSet
+        },
+
+
+        /**
+         * The design set for iCalendar (rfc5545/rfc7265) components.
+         * @type {ICAL.design.designSet}
+         */
+        icalendar: icalSet,
+
+        /**
+         * The design set for vCard (rfc6350/rfc7095) components.
+         * @type {ICAL.design.designSet}
+         */
+        vcard: vcardSet,
+
+        /**
+         * The design set for vCard (rfc2425/rfc2426/rfc7095) components.
+         * @type {ICAL.design.designSet}
+         */
+        vcard3: vcard3Set,
+
+        /**
+         * Gets the design set for the given component name.
+         *
+         * @param {String} componentName        The name of the component
+         * @return {ICAL.design.designSet}      The design set for the component
+         */
+        getDesignSet: function (componentName) {
+            var isInDesign = componentName && componentName in design.components;
+            return isInDesign ? design.components[componentName] : design.defaultSet;
+        }
+    };
+
+    return design;
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * Contains various functions to convert jCal and jCard data back into
+ * iCalendar and vCard.
+ * @namespace
+ */
+ICAL.stringify = (function () {
+    'use strict';
+
+    var LINE_ENDING = '\r\n';
+    var DEFAULT_VALUE_TYPE = 'unknown';
+
+    var design = ICAL.design;
+    var helpers = ICAL.helpers;
+
+    /**
+     * Convert a full jCal/jCard array into a iCalendar/vCard string.
+     *
+     * @function ICAL.stringify
+     * @variation function
+     * @param {Array} jCal    The jCal/jCard document
+     * @return {String}       The stringified iCalendar/vCard document
+     */
+    function stringify(jCal) {
+        if (typeof jCal[0] == "string") {
+            // This is a single component
+            jCal = [jCal];
+        }
+
+        var i = 0;
+        var len = jCal.length;
+        var result = '';
+
+        for (; i < len; i++) {
+            result += stringify.component(jCal[i]) + LINE_ENDING;
+        }
+
+        return result;
+    }
+
+    /**
+     * Converts an jCal component array into a ICAL string.
+     * Recursive will resolve sub-components.
+     *
+     * Exact component/property order is not saved all
+     * properties will come before subcomponents.
+     *
+     * @function ICAL.stringify.component
+     * @param {Array} component
+     *        jCal/jCard fragment of a component
+     * @param {ICAL.design.designSet} designSet
+     *        The design data to use for this component
+     * @return {String}       The iCalendar/vCard string
+     */
+    stringify.component = function (component, designSet) {
+        var name = component[0].toUpperCase();
+        var result = 'BEGIN:' + name + LINE_ENDING;
+
+        var props = component[1];
+        var propIdx = 0;
+        var propLen = props.length;
+
+        var designSetName = component[0];
+        // rfc6350 requires that in vCard 4.0 the first component is the VERSION
+        // component with as value 4.0, note that 3.0 does not have this requirement.
+        if (designSetName === 'vcard' && component[1].length > 0 &&
+            !(component[1][0][0] === "version" && component[1][0][3] === "4.0")) {
+            designSetName = "vcard3";
+        }
+        designSet = designSet || design.getDesignSet(designSetName);
+
+        for (; propIdx < propLen; propIdx++) {
+            result += stringify.property(props[propIdx], designSet) + LINE_ENDING;
+        }
+
+        // Ignore subcomponents if none exist, e.g. in vCard.
+        var comps = component[2] || [];
+        var compIdx = 0;
+        var compLen = comps.length;
+
+        for (; compIdx < compLen; compIdx++) {
+            result += stringify.component(comps[compIdx], designSet) + LINE_ENDING;
+        }
+
+        result += 'END:' + name;
+        return result;
+    };
+
+    /**
+     * Converts a single jCal/jCard property to a iCalendar/vCard string.
+     *
+     * @function ICAL.stringify.property
+     * @param {Array} property
+     *        jCal/jCard property array
+     * @param {ICAL.design.designSet} designSet
+     *        The design data to use for this property
+     * @param {Boolean} noFold
+     *        If true, the line is not folded
+     * @return {String}       The iCalendar/vCard string
+     */
+    stringify.property = function (property, designSet, noFold) {
+        var name = property[0].toUpperCase();
+        var jsName = property[0];
+        var params = property[1];
+
+        var line = name;
+
+        var paramName;
+        for (paramName in params) {
+            var value = params[paramName];
+
+            /* istanbul ignore else */
+            if (params.hasOwnProperty(paramName)) {
+                var multiValue = (paramName in designSet.param) && designSet.param[paramName].multiValue;
+                if (multiValue && Array.isArray(value)) {
+                    if (designSet.param[paramName].multiValueSeparateDQuote) {
+                        multiValue = '"' + multiValue + '"';
+                    }
+                    value = value.map(stringify._rfc6868Unescape);
+                    value = stringify.multiValue(value, multiValue, "unknown", null, designSet);
+                } else {
+                    value = stringify._rfc6868Unescape(value);
+                }
+
+
+                line += ';' + paramName.toUpperCase();
+                line += '=' + stringify.propertyValue(value);
+            }
+        }
+
+        if (property.length === 3) {
+            // If there are no values, we must assume a blank value
+            return line + ':';
+        }
+
+        var valueType = property[2];
+
+        if (!designSet) {
+            designSet = design.defaultSet;
+        }
+
+        var propDetails;
+        var multiValue = false;
+        var structuredValue = false;
+        var isDefault = false;
+
+        if (jsName in designSet.property) {
+            propDetails = designSet.property[jsName];
+
+            if ('multiValue' in propDetails) {
+                multiValue = propDetails.multiValue;
+            }
+
+            if (('structuredValue' in propDetails) && Array.isArray(property[3])) {
+                structuredValue = propDetails.structuredValue;
+            }
+
+            if ('defaultType' in propDetails) {
+                if (valueType === propDetails.defaultType) {
+                    isDefault = true;
+                }
+            } else {
+                if (valueType === DEFAULT_VALUE_TYPE) {
+                    isDefault = true;
+                }
+            }
+        } else {
+            if (valueType === DEFAULT_VALUE_TYPE) {
+                isDefault = true;
+            }
+        }
+
+        // push the VALUE property if type is not the default
+        // for the current property.
+        if (!isDefault) {
+            // value will never contain ;/:/, so we don't escape it here.
+            line += ';VALUE=' + valueType.toUpperCase();
+        }
+
+        line += ':';
+
+        if (multiValue && structuredValue) {
+            line += stringify.multiValue(
+                property[3], structuredValue, valueType, multiValue, designSet, structuredValue
+            );
+        } else if (multiValue) {
+            line += stringify.multiValue(
+                property.slice(3), multiValue, valueType, null, designSet, false
+            );
+        } else if (structuredValue) {
+            line += stringify.multiValue(
+                property[3], structuredValue, valueType, null, designSet, structuredValue
+            );
+        } else {
+            line += stringify.value(property[3], valueType, designSet, false);
+        }
+
+        return noFold ? line : ICAL.helpers.foldline(line);
+    };
+
+    /**
+     * Handles escaping of property values that may contain:
+     *
+     *    COLON (:), SEMICOLON (;), or COMMA (,)
+     *
+     * If any of the above are present the result is wrapped
+     * in double quotes.
+     *
+     * @function ICAL.stringify.propertyValue
+     * @param {String} value      Raw property value
+     * @return {String}           Given or escaped value when needed
+     */
+    stringify.propertyValue = function (value) {
+
+        if ((helpers.unescapedIndexOf(value, ',') === -1) &&
+            (helpers.unescapedIndexOf(value, ':') === -1) &&
+            (helpers.unescapedIndexOf(value, ';') === -1)) {
+
+            return value;
+        }
+
+        return '"' + value + '"';
+    };
+
+    /**
+     * Converts an array of ical values into a single
+     * string based on a type and a delimiter value (like ",").
+     *
+     * @function ICAL.stringify.multiValue
+     * @param {Array} values      List of values to convert
+     * @param {String} delim      Used to join the values (",", ";", ":")
+     * @param {String} type       Lowecase ical value type
+     *        (like boolean, date-time, etc..)
+     * @param {?String} innerMulti If set, each value will again be processed
+     *        Used for structured values
+     * @param {ICAL.design.designSet} designSet
+     *        The design data to use for this property
+     *
+     * @return {String}           iCalendar/vCard string for value
+     */
+    stringify.multiValue = function (values, delim, type, innerMulti, designSet, structuredValue) {
+        var result = '';
+        var len = values.length;
+        var i = 0;
+
+        for (; i < len; i++) {
+            if (innerMulti && Array.isArray(values[i])) {
+                result += stringify.multiValue(values[i], innerMulti, type, null, designSet, structuredValue);
+            } else {
+                result += stringify.value(values[i], type, designSet, structuredValue);
+            }
+
+            if (i !== (len - 1)) {
+                result += delim;
+            }
+        }
+
+        return result;
+    };
+
+    /**
+     * Processes a single ical value runs the associated "toICAL" method from the
+     * design value type if available to convert the value.
+     *
+     * @function ICAL.stringify.value
+     * @param {String|Number} value       A formatted value
+     * @param {String} type               Lowercase iCalendar/vCard value type
+     *  (like boolean, date-time, etc..)
+     * @return {String}                   iCalendar/vCard value for single value
+     */
+    stringify.value = function (value, type, designSet, structuredValue) {
+        if (type in designSet.value && 'toICAL' in designSet.value[type]) {
+            return designSet.value[type].toICAL(value, structuredValue);
+        }
+        return value;
+    };
+
+    /**
+     * Internal helper for rfc6868. Exposing this on ICAL.stringify so that
+     * hackers can disable the rfc6868 parsing if the really need to.
+     *
+     * @param {String} val        The value to unescape
+     * @return {String}           The escaped value
+     */
+    stringify._rfc6868Unescape = function (val) {
+        return val.replace(/[\n^"]/g, function (x) {
+            return RFC6868_REPLACE_MAP[x];
+        });
+    };
+    var RFC6868_REPLACE_MAP = { '"': "^'", "\n": "^n", "^": "^^" };
+
+    return stringify;
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * Contains various functions to parse iCalendar and vCard data.
+ * @namespace
+ */
+ICAL.parse = (function () {
+    'use strict';
+
+    var CHAR = /[^ \t]/;
+    var MULTIVALUE_DELIMITER = ',';
+    var VALUE_DELIMITER = ':';
+    var PARAM_DELIMITER = ';';
+    var PARAM_NAME_DELIMITER = '=';
+    var DEFAULT_VALUE_TYPE = 'unknown';
+    var DEFAULT_PARAM_TYPE = 'text';
+
+    var design = ICAL.design;
+    var helpers = ICAL.helpers;
+
+    /**
+     * An error that occurred during parsing.
+     *
+     * @param {String} message        The error message
+     * @memberof ICAL.parse
+     * @extends {Error}
+     * @class
+     */
+    function ParserError(message) {
+        this.message = message;
+        this.name = 'ParserError';
+
+        try {
+            throw new Error();
+        } catch (e) {
+            if (e.stack) {
+                var split = e.stack.split('\n');
+                split.shift();
+                this.stack = split.join('\n');
+            }
+        }
+    }
+
+    ParserError.prototype = Error.prototype;
+
+    /**
+     * Parses iCalendar or vCard data into a raw jCal object. Consult
+     * documentation on the {@tutorial layers|layers of parsing} for more
+     * details.
+     *
+     * @function ICAL.parse
+     * @variation function
+     * @todo Fix the API to be more clear on the return type
+     * @param {String} input      The string data to parse
+     * @return {Object|Object[]}  A single jCal object, or an array thereof
+     */
+    function parser(input) {
+        var state = {};
+        var root = state.component = [];
+
+        state.stack = [root];
+
+        parser._eachLine(input, function (err, line) {
+            parser._handleContentLine(line, state);
+        });
+
+
+        // when there are still items on the stack
+        // throw a fatal error, a component was not closed
+        // correctly in that case.
+        if (state.stack.length > 1) {
+            throw new ParserError(
+                'invalid ical body. component began but did not end'
+            );
+        }
+
+        state = null;
+
+        return (root.length == 1 ? root[0] : root);
+    }
+
+    /**
+     * Parse an iCalendar property value into the jCal for a single property
+     *
+     * @function ICAL.parse.property
+     * @param {String} str
+     *   The iCalendar property string to parse
+     * @param {ICAL.design.designSet=} designSet
+     *   The design data to use for this property
+     * @return {Object}
+     *   The jCal Object containing the property
+     */
+    parser.property = function (str, designSet) {
+        var state = {
+            component: [[], []],
+            designSet: designSet || design.defaultSet
+        };
+        parser._handleContentLine(str, state);
+        return state.component[1][0];
+    };
+
+    /**
+     * Convenience method to parse a component. You can use ICAL.parse() directly
+     * instead.
+     *
+     * @function ICAL.parse.component
+     * @see ICAL.parse(function)
+     * @param {String} str    The iCalendar component string to parse
+     * @return {Object}       The jCal Object containing the component
+     */
+    parser.component = function (str) {
+        return parser(str);
+    };
+
+    // classes & constants
+    parser.ParserError = ParserError;
+
+    /**
+     * The state for parsing content lines from an iCalendar/vCard string.
+     *
+     * @private
+     * @memberof ICAL.parse
+     * @typedef {Object} parserState
+     * @property {ICAL.design.designSet} designSet    The design set to use for parsing
+     * @property {ICAL.Component[]} stack             The stack of components being processed
+     * @property {ICAL.Component} component           The currently active component
+     */
+
+
+    /**
+     * Handles a single line of iCalendar/vCard, updating the state.
+     *
+     * @private
+     * @function ICAL.parse._handleContentLine
+     * @param {String} line               The content line to process
+     * @param {ICAL.parse.parserState}    The current state of the line parsing
+     */
+    parser._handleContentLine = function (line, state) {
+        // break up the parts of the line
+        var valuePos = line.indexOf(VALUE_DELIMITER);
+        var paramPos = line.indexOf(PARAM_DELIMITER);
+
+        var lastParamIndex;
+        var lastValuePos;
+
+        // name of property or begin/end
+        var name;
+        var value;
+        // params is only overridden if paramPos !== -1.
+        // we can't do params = params || {} later on
+        // because it sacrifices ops.
+        var params = {};
+
+        /**
+         * Different property cases
+         *
+         *
+         * 1. RRULE:FREQ=foo
+         *    // FREQ= is not a param but the value
+         *
+         * 2. ATTENDEE;ROLE=REQ-PARTICIPANT;
+         *    // ROLE= is a param because : has not happened yet
+         */
+        // when the parameter delimiter is after the
+        // value delimiter then it is not a parameter.
+
+        if ((paramPos !== -1 && valuePos !== -1)) {
+            // when the parameter delimiter is after the
+            // value delimiter then it is not a parameter.
+            if (paramPos > valuePos) {
+                paramPos = -1;
+            }
+        }
+
+        var parsedParams;
+        if (paramPos !== -1) {
+            name = line.substring(0, paramPos).toLowerCase();
+            parsedParams = parser._parseParameters(line.substring(paramPos), 0, state.designSet);
+            if (parsedParams[2] == -1) {
+                throw new ParserError("Invalid parameters in '" + line + "'");
+            }
+            params = parsedParams[0];
+            lastParamIndex = parsedParams[1].length + parsedParams[2] + paramPos;
+            if ((lastValuePos =
+                line.substring(lastParamIndex).indexOf(VALUE_DELIMITER)) !== -1) {
+                value = line.substring(lastParamIndex + lastValuePos + 1);
+            } else {
+                throw new ParserError("Missing parameter value in '" + line + "'");
+            }
+        } else if (valuePos !== -1) {
+            // without parmeters (BEGIN:VCAENDAR, CLASS:PUBLIC)
+            name = line.substring(0, valuePos).toLowerCase();
+            value = line.substring(valuePos + 1);
+
+            if (name === 'begin') {
+                var newComponent = [value.toLowerCase(), [], []];
+                if (state.stack.length === 1) {
+                    state.component.push(newComponent);
+                } else {
+                    state.component[2].push(newComponent);
+                }
+                state.stack.push(state.component);
+                state.component = newComponent;
+                if (!state.designSet) {
+                    state.designSet = design.getDesignSet(state.component[0]);
+                }
+                return;
+            } else if (name === 'end') {
+                state.component = state.stack.pop();
+                return;
+            }
+            // If it is not begin/end, then this is a property with an empty value,
+            // which should be considered valid.
+        } else {
+            /**
+             * Invalid line.
+             * The rational to throw an error is we will
+             * never be certain that the rest of the file
+             * is sane and it is unlikely that we can serialize
+             * the result correctly either.
+             */
+            throw new ParserError(
+                'invalid line (no token ";" or ":") "' + line + '"'
+            );
+        }
+
+        var valueType;
+        var multiValue = false;
+        var structuredValue = false;
+        var propertyDetails;
+
+        if (name in state.designSet.property) {
+            propertyDetails = state.designSet.property[name];
+
+            if ('multiValue' in propertyDetails) {
+                multiValue = propertyDetails.multiValue;
+            }
+
+            if ('structuredValue' in propertyDetails) {
+                structuredValue = propertyDetails.structuredValue;
+            }
+
+            if (value && 'detectType' in propertyDetails) {
+                valueType = propertyDetails.detectType(value);
+            }
+        }
+
+        // attempt to determine value
+        if (!valueType) {
+            if (!('value' in params)) {
+                if (propertyDetails) {
+                    valueType = propertyDetails.defaultType;
+                } else {
+                    valueType = DEFAULT_VALUE_TYPE;
+                }
+            } else {
+                // possible to avoid this?
+                valueType = params.value.toLowerCase();
+            }
+        }
+
+        delete params.value;
+
+        /**
+         * Note on `var result` juggling:
+         *
+         * I observed that building the array in pieces has adverse
+         * effects on performance, so where possible we inline the creation.
+         * It is a little ugly but resulted in ~2000 additional ops/sec.
+         */
+
+        var result;
+        if (multiValue && structuredValue) {
+            value = parser._parseMultiValue(value, structuredValue, valueType, [], multiValue, state.designSet, structuredValue);
+            result = [name, params, valueType, value];
+        } else if (multiValue) {
+            result = [name, params, valueType];
+            parser._parseMultiValue(value, multiValue, valueType, result, null, state.designSet, false);
+        } else if (structuredValue) {
+            value = parser._parseMultiValue(value, structuredValue, valueType, [], null, state.designSet, structuredValue);
+            result = [name, params, valueType, value];
+        } else {
+            value = parser._parseValue(value, valueType, state.designSet, false);
+            result = [name, params, valueType, value];
+        }
+        // rfc6350 requires that in vCard 4.0 the first component is the VERSION
+        // component with as value 4.0, note that 3.0 does not have this requirement.
+        if (state.component[0] === 'vcard' && state.component[1].length === 0 &&
+            !(name === 'version' && value === '4.0')) {
+            state.designSet = design.getDesignSet("vcard3");
+        }
+        state.component[1].push(result);
+    };
+
+    /**
+     * Parse a value from the raw value into the jCard/jCal value.
+     *
+     * @private
+     * @function ICAL.parse._parseValue
+     * @param {String} value          Original value
+     * @param {String} type           Type of value
+     * @param {Object} designSet      The design data to use for this value
+     * @return {Object} varies on type
+     */
+    parser._parseValue = function (value, type, designSet, structuredValue) {
+        if (type in designSet.value && 'fromICAL' in designSet.value[type]) {
+            return designSet.value[type].fromICAL(value, structuredValue);
+        }
+        return value;
+    };
+
+    /**
+     * Parse parameters from a string to object.
+     *
+     * @function ICAL.parse._parseParameters
+     * @private
+     * @param {String} line           A single unfolded line
+     * @param {Numeric} start         Position to start looking for properties
+     * @param {Object} designSet      The design data to use for this property
+     * @return {Object} key/value pairs
+     */
+    parser._parseParameters = function (line, start, designSet) {
+        var lastParam = start;
+        var pos = 0;
+        var delim = PARAM_NAME_DELIMITER;
+        var result = {};
+        var name, lcname;
+        var value, valuePos = -1;
+        var type, multiValue, mvdelim;
+
+        // find the next '=' sign
+        // use lastParam and pos to find name
+        // check if " is used if so get value from "->"
+        // then increment pos to find next ;
+
+        while ((pos !== false) &&
+            (pos = helpers.unescapedIndexOf(line, delim, pos + 1)) !== -1) {
+
+            name = line.substr(lastParam + 1, pos - lastParam - 1);
+            if (name.length == 0) {
+                throw new ParserError("Empty parameter name in '" + line + "'");
+            }
+            lcname = name.toLowerCase();
+            mvdelim = false;
+            multiValue = false;
+
+            if (lcname in designSet.param && designSet.param[lcname].valueType) {
+                type = designSet.param[lcname].valueType;
+            } else {
+                type = DEFAULT_PARAM_TYPE;
+            }
+
+            if (lcname in designSet.param) {
+                multiValue = designSet.param[lcname].multiValue;
+                if (designSet.param[lcname].multiValueSeparateDQuote) {
+                    mvdelim = parser._rfc6868Escape('"' + multiValue + '"');
+                }
+            }
+
+            var nextChar = line[pos + 1];
+            if (nextChar === '"') {
+                valuePos = pos + 2;
+                pos = helpers.unescapedIndexOf(line, '"', valuePos);
+                if (multiValue && pos != -1) {
+                    var extendedValue = true;
+                    while (extendedValue) {
+                        if (line[pos + 1] == multiValue && line[pos + 2] == '"') {
+                            pos = helpers.unescapedIndexOf(line, '"', pos + 3);
+                        } else {
+                            extendedValue = false;
+                        }
+                    }
+                }
+                if (pos === -1) {
+                    throw new ParserError(
+                        'invalid line (no matching double quote) "' + line + '"'
+                    );
+                }
+                value = line.substr(valuePos, pos - valuePos);
+                lastParam = helpers.unescapedIndexOf(line, PARAM_DELIMITER, pos);
+                if (lastParam === -1) {
+                    pos = false;
+                }
+            } else {
+                valuePos = pos + 1;
+
+                // move to next ";"
+                var nextPos = helpers.unescapedIndexOf(line, PARAM_DELIMITER, valuePos);
+                var propValuePos = helpers.unescapedIndexOf(line, VALUE_DELIMITER, valuePos);
+                if (propValuePos !== -1 && nextPos > propValuePos) {
+                    // this is a delimiter in the property value, let's stop here
+                    nextPos = propValuePos;
+                    pos = false;
+                } else if (nextPos === -1) {
+                    // no ";"
+                    if (propValuePos === -1) {
+                        nextPos = line.length;
+                    } else {
+                        nextPos = propValuePos;
+                    }
+                    pos = false;
+                } else {
+                    lastParam = nextPos;
+                    pos = nextPos;
+                }
+
+                value = line.substr(valuePos, nextPos - valuePos);
+            }
+
+            value = parser._rfc6868Escape(value);
+            if (multiValue) {
+                var delimiter = mvdelim || multiValue;
+                value = parser._parseMultiValue(value, delimiter, type, [], null, designSet);
+            } else {
+                value = parser._parseValue(value, type, designSet);
+            }
+
+            if (multiValue && (lcname in result)) {
+                if (Array.isArray(result[lcname])) {
+                    result[lcname].push(value);
+                } else {
+                    result[lcname] = [
+                        result[lcname],
+                        value
+                    ];
+                }
+            } else {
+                result[lcname] = value;
+            }
+        }
+        return [result, value, valuePos];
+    };
+
+    /**
+     * Internal helper for rfc6868. Exposing this on ICAL.parse so that
+     * hackers can disable the rfc6868 parsing if the really need to.
+     *
+     * @function ICAL.parse._rfc6868Escape
+     * @param {String} val        The value to escape
+     * @return {String}           The escaped value
+     */
+    parser._rfc6868Escape = function (val) {
+        return val.replace(/\^['n^]/g, function (x) {
+            return RFC6868_REPLACE_MAP[x];
+        });
+    };
+    var RFC6868_REPLACE_MAP = { "^'": '"', "^n": "\n", "^^": "^" };
+
+    /**
+     * Parse a multi value string. This function is used either for parsing
+     * actual multi-value property's values, or for handling parameter values. It
+     * can be used for both multi-value properties and structured value properties.
+     *
+     * @private
+     * @function ICAL.parse._parseMultiValue
+     * @param {String} buffer     The buffer containing the full value
+     * @param {String} delim      The multi-value delimiter
+     * @param {String} type       The value type to be parsed
+     * @param {Array.<?>} result        The array to append results to, varies on value type
+     * @param {String} innerMulti The inner delimiter to split each value with
+     * @param {ICAL.design.designSet} designSet   The design data for this value
+     * @return {?|Array.<?>}            Either an array of results, or the first result
+     */
+    parser._parseMultiValue = function (buffer, delim, type, result, innerMulti, designSet, structuredValue) {
+        var pos = 0;
+        var lastPos = 0;
+        var value;
+        if (delim.length === 0) {
+            return buffer;
+        }
+
+        // split each piece
+        while ((pos = helpers.unescapedIndexOf(buffer, delim, lastPos)) !== -1) {
+            value = buffer.substr(lastPos, pos - lastPos);
+            if (innerMulti) {
+                value = parser._parseMultiValue(value, innerMulti, type, [], null, designSet, structuredValue);
+            } else {
+                value = parser._parseValue(value, type, designSet, structuredValue);
+            }
+            result.push(value);
+            lastPos = pos + delim.length;
+        }
+
+        // on the last piece take the rest of string
+        value = buffer.substr(lastPos);
+        if (innerMulti) {
+            value = parser._parseMultiValue(value, innerMulti, type, [], null, designSet, structuredValue);
+        } else {
+            value = parser._parseValue(value, type, designSet, structuredValue);
+        }
+        result.push(value);
+
+        return result.length == 1 ? result[0] : result;
+    };
+
+    /**
+     * Process a complete buffer of iCalendar/vCard data line by line, correctly
+     * unfolding content. Each line will be processed with the given callback
+     *
+     * @private
+     * @function ICAL.parse._eachLine
+     * @param {String} buffer                         The buffer to process
+     * @param {function(?String, String)} callback    The callback for each line
+     */
+    parser._eachLine = function (buffer, callback) {
+        var len = buffer.length;
+        var lastPos = buffer.search(CHAR);
+        var pos = lastPos;
+        var line;
+        var firstChar;
+
+        var newlineOffset;
+
+        do {
+            pos = buffer.indexOf('\n', lastPos) + 1;
+
+            if (pos > 1 && buffer[pos - 2] === '\r') {
+                newlineOffset = 2;
+            } else {
+                newlineOffset = 1;
+            }
+
+            if (pos === 0) {
+                pos = len;
+                newlineOffset = 0;
+            }
+
+            firstChar = buffer[lastPos];
+
+            if (firstChar === ' ' || firstChar === '\t') {
+                // add to line
+                line += buffer.substr(
+                    lastPos + 1,
+                    pos - lastPos - (newlineOffset + 1)
+                );
+            } else {
+                if (line)
+                    callback(null, line);
+                // push line
+                line = buffer.substr(
+                    lastPos,
+                    pos - lastPos - newlineOffset
+                );
+            }
+
+            lastPos = pos;
+        } while (pos !== len);
+
+        // extra ending line
+        line = line.trim();
+
+        if (line.length)
+            callback(null, line);
+    };
+
+    return parser;
+
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * This symbol is further described later on
+ * @ignore
+ */
+ICAL.Component = (function () {
+    'use strict';
+
+    var PROPERTY_INDEX = 1;
+    var COMPONENT_INDEX = 2;
+    var NAME_INDEX = 0;
+
+    /**
+     * @classdesc
+     * Wraps a jCal component, adding convenience methods to add, remove and
+     * update subcomponents and properties.
+     *
+     * @class
+     * @alias ICAL.Component
+     * @param {Array|String} jCal         Raw jCal component data OR name of new
+     *                                      component
+     * @param {ICAL.Component} parent     Parent component to associate
+     */
+    function Component(jCal, parent) {
+        if (typeof (jCal) === 'string') {
+            // jCal spec (name, properties, components)
+            jCal = [jCal, [], []];
+        }
+
+        // mostly for legacy reasons.
+        this.jCal = jCal;
+
+        this.parent = parent || null;
+    }
+
+    Component.prototype = {
+        /**
+         * Hydrated properties are inserted into the _properties array at the same
+         * position as in the jCal array, so it is possible that the array contains
+         * undefined values for unhydrdated properties. To avoid iterating the
+         * array when checking if all properties have been hydrated, we save the
+         * count here.
+         *
+         * @type {Number}
+         * @private
+         */
+        _hydratedPropertyCount: 0,
+
+        /**
+         * The same count as for _hydratedPropertyCount, but for subcomponents
+         *
+         * @type {Number}
+         * @private
+         */
+        _hydratedComponentCount: 0,
+
+        /**
+         * The name of this component
+         * @readonly
+         */
+        get name() {
+            return this.jCal[NAME_INDEX];
+        },
+
+        /**
+         * The design set for this component, e.g. icalendar vs vcard
+         *
+         * @type {ICAL.design.designSet}
+         * @private
+         */
+        get _designSet() {
+            var parentDesign = this.parent && this.parent._designSet;
+            return parentDesign || ICAL.design.getDesignSet(this.name);
+        },
+
+        _hydrateComponent: function (index) {
+            if (!this._components) {
+                this._components = [];
+                this._hydratedComponentCount = 0;
+            }
+
+            if (this._components[index]) {
+                return this._components[index];
+            }
+
+            var comp = new Component(
+                this.jCal[COMPONENT_INDEX][index],
+                this
+            );
+
+            this._hydratedComponentCount++;
+            return (this._components[index] = comp);
+        },
+
+        _hydrateProperty: function (index) {
+            if (!this._properties) {
+                this._properties = [];
+                this._hydratedPropertyCount = 0;
+            }
+
+            if (this._properties[index]) {
+                return this._properties[index];
+            }
+
+            var prop = new ICAL.Property(
+                this.jCal[PROPERTY_INDEX][index],
+                this
+            );
+
+            this._hydratedPropertyCount++;
+            return (this._properties[index] = prop);
+        },
+
+        /**
+         * Finds first sub component, optionally filtered by name.
+         *
+         * @param {String=} name        Optional name to filter by
+         * @return {?ICAL.Component}     The found subcomponent
+         */
+        getFirstSubcomponent: function (name) {
+            if (name) {
+                var i = 0;
+                var comps = this.jCal[COMPONENT_INDEX];
+                var len = comps.length;
+
+                for (; i < len; i++) {
+                    if (comps[i][NAME_INDEX] === name) {
+                        var result = this._hydrateComponent(i);
+                        return result;
+                    }
+                }
+            } else {
+                if (this.jCal[COMPONENT_INDEX].length) {
+                    return this._hydrateComponent(0);
+                }
+            }
+
+            // ensure we return a value (strict mode)
+            return null;
+        },
+
+        /**
+         * Finds all sub components, optionally filtering by name.
+         *
+         * @param {String=} name            Optional name to filter by
+         * @return {ICAL.Component[]}       The found sub components
+         */
+        getAllSubcomponents: function (name) {
+            var jCalLen = this.jCal[COMPONENT_INDEX].length;
+            var i = 0;
+
+            if (name) {
+                var comps = this.jCal[COMPONENT_INDEX];
+                var result = [];
+
+                for (; i < jCalLen; i++) {
+                    if (name === comps[i][NAME_INDEX]) {
+                        result.push(
+                            this._hydrateComponent(i)
+                        );
+                    }
+                }
+                return result;
+            } else {
+                if (!this._components ||
+                    (this._hydratedComponentCount !== jCalLen)) {
+                    for (; i < jCalLen; i++) {
+                        this._hydrateComponent(i);
+                    }
+                }
+
+                return this._components || [];
+            }
+        },
+
+        /**
+         * Returns true when a named property exists.
+         *
+         * @param {String} name     The property name
+         * @return {Boolean}        True, when property is found
+         */
+        hasProperty: function (name) {
+            var props = this.jCal[PROPERTY_INDEX];
+            var len = props.length;
+
+            var i = 0;
+            for (; i < len; i++) {
+                // 0 is property name
+                if (props[i][NAME_INDEX] === name) {
+                    return true;
+                }
+            }
+
+            return false;
+        },
+
+        /**
+         * Finds the first property, optionally with the given name.
+         *
+         * @param {String=} name        Lowercase property name
+         * @return {?ICAL.Property}     The found property
+         */
+        getFirstProperty: function (name) {
+            if (name) {
+                var i = 0;
+                var props = this.jCal[PROPERTY_INDEX];
+                var len = props.length;
+
+                for (; i < len; i++) {
+                    if (props[i][NAME_INDEX] === name) {
+                        var result = this._hydrateProperty(i);
+                        return result;
+                    }
+                }
+            } else {
+                if (this.jCal[PROPERTY_INDEX].length) {
+                    return this._hydrateProperty(0);
+                }
+            }
+
+            return null;
+        },
+
+        /**
+         * Returns first property's value, if available.
+         *
+         * @param {String=} name    Lowercase property name
+         * @return {?String}        The found property value.
+         */
+        getFirstPropertyValue: function (name) {
+            var prop = this.getFirstProperty(name);
+            if (prop) {
+                return prop.getFirstValue();
+            }
+
+            return null;
+        },
+
+        /**
+         * Get all properties in the component, optionally filtered by name.
+         *
+         * @param {String=} name        Lowercase property name
+         * @return {ICAL.Property[]}    List of properties
+         */
+        getAllProperties: function (name) {
+            var jCalLen = this.jCal[PROPERTY_INDEX].length;
+            var i = 0;
+
+            if (name) {
+                var props = this.jCal[PROPERTY_INDEX];
+                var result = [];
+
+                for (; i < jCalLen; i++) {
+                    if (name === props[i][NAME_INDEX]) {
+                        result.push(
+                            this._hydrateProperty(i)
+                        );
+                    }
+                }
+                return result;
+            } else {
+                if (!this._properties ||
+                    (this._hydratedPropertyCount !== jCalLen)) {
+                    for (; i < jCalLen; i++) {
+                        this._hydrateProperty(i);
+                    }
+                }
+
+                return this._properties || [];
+            }
+        },
+
+        _removeObjectByIndex: function (jCalIndex, cache, index) {
+            cache = cache || [];
+            // remove cached version
+            if (cache[index]) {
+                var obj = cache[index];
+                if ("parent" in obj) {
+                    obj.parent = null;
+                }
+            }
+
+            cache.splice(index, 1);
+
+            // remove it from the jCal
+            this.jCal[jCalIndex].splice(index, 1);
+        },
+
+        _removeObject: function (jCalIndex, cache, nameOrObject) {
+            var i = 0;
+            var objects = this.jCal[jCalIndex];
+            var len = objects.length;
+            var cached = this[cache];
+
+            if (typeof (nameOrObject) === 'string') {
+                for (; i < len; i++) {
+                    if (objects[i][NAME_INDEX] === nameOrObject) {
+                        this._removeObjectByIndex(jCalIndex, cached, i);
+                        return true;
+                    }
+                }
+            } else if (cached) {
+                for (; i < len; i++) {
+                    if (cached[i] && cached[i] === nameOrObject) {
+                        this._removeObjectByIndex(jCalIndex, cached, i);
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        },
+
+        _removeAllObjects: function (jCalIndex, cache, name) {
+            var cached = this[cache];
+
+            // Unfortunately we have to run through all children to reset their
+            // parent property.
+            var objects = this.jCal[jCalIndex];
+            var i = objects.length - 1;
+
+            // descending search required because splice
+            // is used and will effect the indices.
+            for (; i >= 0; i--) {
+                if (!name || objects[i][NAME_INDEX] === name) {
+                    this._removeObjectByIndex(jCalIndex, cached, i);
+                }
+            }
+        },
+
+        /**
+         * Adds a single sub component.
+         *
+         * @param {ICAL.Component} component        The component to add
+         * @return {ICAL.Component}                 The passed in component
+         */
+        addSubcomponent: function (component) {
+            if (!this._components) {
+                this._components = [];
+                this._hydratedComponentCount = 0;
+            }
+
+            if (component.parent) {
+                component.parent.removeSubcomponent(component);
+            }
+
+            var idx = this.jCal[COMPONENT_INDEX].push(component.jCal);
+            this._components[idx - 1] = component;
+            this._hydratedComponentCount++;
+            component.parent = this;
+            return component;
+        },
+
+        /**
+         * Removes a single component by name or the instance of a specific
+         * component.
+         *
+         * @param {ICAL.Component|String} nameOrComp    Name of component, or component
+         * @return {Boolean}                            True when comp is removed
+         */
+        removeSubcomponent: function (nameOrComp) {
+            var removed = this._removeObject(COMPONENT_INDEX, '_components', nameOrComp);
+            if (removed) {
+                this._hydratedComponentCount--;
+            }
+            return removed;
+        },
+
+        /**
+         * Removes all components or (if given) all components by a particular
+         * name.
+         *
+         * @param {String=} name            Lowercase component name
+         */
+        removeAllSubcomponents: function (name) {
+            var removed = this._removeAllObjects(COMPONENT_INDEX, '_components', name);
+            this._hydratedComponentCount = 0;
+            return removed;
+        },
+
+        /**
+         * Adds an {@link ICAL.Property} to the component.
+         *
+         * @param {ICAL.Property} property      The property to add
+         * @return {ICAL.Property}              The passed in property
+         */
+        addProperty: function (property) {
+            if (!(property instanceof ICAL.Property)) {
+                throw new TypeError('must instance of ICAL.Property');
+            }
+
+            if (!this._properties) {
+                this._properties = [];
+                this._hydratedPropertyCount = 0;
+            }
+
+            if (property.parent) {
+                property.parent.removeProperty(property);
+            }
+
+            var idx = this.jCal[PROPERTY_INDEX].push(property.jCal);
+            this._properties[idx - 1] = property;
+            this._hydratedPropertyCount++;
+            property.parent = this;
+            return property;
+        },
+
+        /**
+         * Helper method to add a property with a value to the component.
+         *
+         * @param {String}               name         Property name to add
+         * @param {String|Number|Object} value        Property value
+         * @return {ICAL.Property}                    The created property
+         */
+        addPropertyWithValue: function (name, value) {
+            var prop = new ICAL.Property(name);
+            prop.setValue(value);
+
+            this.addProperty(prop);
+
+            return prop;
+        },
+
+        /**
+         * Helper method that will update or create a property of the given name
+         * and sets its value. If multiple properties with the given name exist,
+         * only the first is updated.
+         *
+         * @param {String}               name         Property name to update
+         * @param {String|Number|Object} value        Property value
+         * @return {ICAL.Property}                    The created property
+         */
+        updatePropertyWithValue: function (name, value) {
+            var prop = this.getFirstProperty(name);
+
+            if (prop) {
+                prop.setValue(value);
+            } else {
+                prop = this.addPropertyWithValue(name, value);
+            }
+
+            return prop;
+        },
+
+        /**
+         * Removes a single property by name or the instance of the specific
+         * property.
+         *
+         * @param {String|ICAL.Property} nameOrProp     Property name or instance to remove
+         * @return {Boolean}                            True, when deleted
+         */
+        removeProperty: function (nameOrProp) {
+            var removed = this._removeObject(PROPERTY_INDEX, '_properties', nameOrProp);
+            if (removed) {
+                this._hydratedPropertyCount--;
+            }
+            return removed;
+        },
+
+        /**
+         * Removes all properties associated with this component, optionally
+         * filtered by name.
+         *
+         * @param {String=} name        Lowercase property name
+         * @return {Boolean}            True, when deleted
+         */
+        removeAllProperties: function (name) {
+            var removed = this._removeAllObjects(PROPERTY_INDEX, '_properties', name);
+            this._hydratedPropertyCount = 0;
+            return removed;
+        },
+
+        /**
+         * Returns the Object representation of this component. The returned object
+         * is a live jCal object and should be cloned if modified.
+         * @return {Object}
+         */
+        toJSON: function () {
+            return this.jCal;
+        },
+
+        /**
+         * The string representation of this component.
+         * @return {String}
+         */
+        toString: function () {
+            return ICAL.stringify.component(
+                this.jCal, this._designSet
+            );
+        }
+    };
+
+    /**
+     * Create an {@link ICAL.Component} by parsing the passed iCalendar string.
+     *
+     * @param {String} str        The iCalendar string to parse
+     */
+    Component.fromString = function (str) {
+        return new Component(ICAL.parse.component(str));
+    };
+
+    return Component;
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * This symbol is further described later on
+ * @ignore
+ */
+ICAL.Property = (function () {
+    'use strict';
+
+    var NAME_INDEX = 0;
+    var PROP_INDEX = 1;
+    var TYPE_INDEX = 2;
+    var VALUE_INDEX = 3;
+
+    var design = ICAL.design;
+
+    /**
+     * @classdesc
+     * Provides a layer on top of the raw jCal object for manipulating a single
+     * property, with its parameters and value.
+     *
+     * @description
+     * It is important to note that mutations done in the wrapper
+     * directly mutate the jCal object used to initialize.
+     *
+     * Can also be used to create new properties by passing
+     * the name of the property (as a String).
+     *
+     * @class
+     * @alias ICAL.Property
+     * @param {Array|String} jCal         Raw jCal representation OR
+     *  the new name of the property
+     *
+     * @param {ICAL.Component=} parent    Parent component
+     */
+    function Property(jCal, parent) {
+        this._parent = parent || null;
+
+        if (typeof (jCal) === 'string') {
+            // We are creating the property by name and need to detect the type
+            this.jCal = [jCal, {}, design.defaultType];
+            this.jCal[TYPE_INDEX] = this.getDefaultType();
+        } else {
+            this.jCal = jCal;
+        }
+        this._updateType();
+    }
+
+    Property.prototype = {
+
+        /**
+         * The value type for this property
+         * @readonly
+         * @type {String}
+         */
+        get type() {
+            return this.jCal[TYPE_INDEX];
+        },
+
+        /**
+         * The name of this property, in lowercase.
+         * @readonly
+         * @type {String}
+         */
+        get name() {
+            return this.jCal[NAME_INDEX];
+        },
+
+        /**
+         * The parent component for this property.
+         * @type {ICAL.Component}
+         */
+        get parent() {
+            return this._parent;
+        },
+
+        set parent(p) {
+            // Before setting the parent, check if the design set has changed. If it
+            // has, we later need to update the type if it was unknown before.
+            var designSetChanged = !this._parent || (p && p._designSet != this._parent._designSet);
+
+            this._parent = p;
+
+            if (this.type == design.defaultType && designSetChanged) {
+                this.jCal[TYPE_INDEX] = this.getDefaultType();
+                this._updateType();
+            }
+
+            return p;
+        },
+
+        /**
+         * The design set for this property, e.g. icalendar vs vcard
+         *
+         * @type {ICAL.design.designSet}
+         * @private
+         */
+        get _designSet() {
+            return this.parent ? this.parent._designSet : design.defaultSet;
+        },
+
+        /**
+         * Updates the type metadata from the current jCal type and design set.
+         *
+         * @private
+         */
+        _updateType: function () {
+            var designSet = this._designSet;
+
+            if (this.type in designSet.value) {
+                var designType = designSet.value[this.type];
+
+                if ('decorate' in designSet.value[this.type]) {
+                    this.isDecorated = true;
+                } else {
+                    this.isDecorated = false;
+                }
+
+                if (this.name in designSet.property) {
+                    this.isMultiValue = ('multiValue' in designSet.property[this.name]);
+                    this.isStructuredValue = ('structuredValue' in designSet.property[this.name]);
+                }
+            }
+        },
+
+        /**
+         * Hydrate a single value. The act of hydrating means turning the raw jCal
+         * value into a potentially wrapped object, for example {@link ICAL.Time}.
+         *
+         * @private
+         * @param {Number} index        The index of the value to hydrate
+         * @return {Object}             The decorated value.
+         */
+        _hydrateValue: function (index) {
+            if (this._values && this._values[index]) {
+                return this._values[index];
+            }
+
+            // for the case where there is no value.
+            if (this.jCal.length <= (VALUE_INDEX + index)) {
+                return null;
+            }
+
+            if (this.isDecorated) {
+                if (!this._values) {
+                    this._values = [];
+                }
+                return (this._values[index] = this._decorate(
+                    this.jCal[VALUE_INDEX + index]
+                ));
+            } else {
+                return this.jCal[VALUE_INDEX + index];
+            }
+        },
+
+        /**
+         * Decorate a single value, returning its wrapped object. This is used by
+         * the hydrate function to actually wrap the value.
+         *
+         * @private
+         * @param {?} value         The value to decorate
+         * @return {Object}         The decorated value
+         */
+        _decorate: function (value) {
+            return this._designSet.value[this.type].decorate(value, this);
+        },
+
+        /**
+         * Undecorate a single value, returning its raw jCal data.
+         *
+         * @private
+         * @param {Object} value         The value to undecorate
+         * @return {?}                   The undecorated value
+         */
+        _undecorate: function (value) {
+            return this._designSet.value[this.type].undecorate(value, this);
+        },
+
+        /**
+         * Sets the value at the given index while also hydrating it. The passed
+         * value can either be a decorated or undecorated value.
+         *
+         * @private
+         * @param {?} value             The value to set
+         * @param {Number} index        The index to set it at
+         */
+        _setDecoratedValue: function (value, index) {
+            if (!this._values) {
+                this._values = [];
+            }
+
+            if (typeof (value) === 'object' && 'icaltype' in value) {
+                // decorated value
+                this.jCal[VALUE_INDEX + index] = this._undecorate(value);
+                this._values[index] = value;
+            } else {
+                // undecorated value
+                this.jCal[VALUE_INDEX + index] = value;
+                this._values[index] = this._decorate(value);
+            }
+        },
+
+        /**
+         * Gets a parameter on the property.
+         *
+         * @param {String}        name   Parameter name (lowercase)
+         * @return {Array|String}        Parameter value
+         */
+        getParameter: function (name) {
+            if (name in this.jCal[PROP_INDEX]) {
+                return this.jCal[PROP_INDEX][name];
+            } else {
+                return undefined;
+            }
+        },
+
+        /**
+         * Gets first parameter on the property.
+         *
+         * @param {String}        name   Parameter name (lowercase)
+         * @return {String}        Parameter value
+         */
+        getFirstParameter: function (name) {
+            var parameters = this.getParameter(name);
+
+            if (Array.isArray(parameters)) {
+                return parameters[0];
+            }
+
+            return parameters;
+        },
+
+        /**
+         * Sets a parameter on the property.
+         *
+         * @param {String}       name     The parameter name
+         * @param {Array|String} value    The parameter value
+         */
+        setParameter: function (name, value) {
+            var lcname = name.toLowerCase();
+            if (typeof value === "string" &&
+                lcname in this._designSet.param &&
+                'multiValue' in this._designSet.param[lcname]) {
+                value = [value];
+            }
+            this.jCal[PROP_INDEX][name] = value;
+        },
+
+        /**
+         * Removes a parameter
+         *
+         * @param {String} name     The parameter name
+         */
+        removeParameter: function (name) {
+            delete this.jCal[PROP_INDEX][name];
+        },
+
+        /**
+         * Get the default type based on this property's name.
+         *
+         * @return {String}     The default type for this property
+         */
+        getDefaultType: function () {
+            var name = this.jCal[NAME_INDEX];
+            var designSet = this._designSet;
+
+            if (name in designSet.property) {
+                var details = designSet.property[name];
+                if ('defaultType' in details) {
+                    return details.defaultType;
+                }
+            }
+            return design.defaultType;
+        },
+
+        /**
+         * Sets type of property and clears out any existing values of the current
+         * type.
+         *
+         * @param {String} type     New iCAL type (see design.*.values)
+         */
+        resetType: function (type) {
+            this.removeAllValues();
+            this.jCal[TYPE_INDEX] = type;
+            this._updateType();
+        },
+
+        /**
+         * Finds the first property value.
+         *
+         * @return {String}         First property value
+         */
+        getFirstValue: function () {
+            return this._hydrateValue(0);
+        },
+
+        /**
+         * Gets all values on the property.
+         *
+         * NOTE: this creates an array during each call.
+         *
+         * @return {Array}          List of values
+         */
+        getValues: function () {
+            var len = this.jCal.length - VALUE_INDEX;
+
+            if (len < 1) {
+                // it is possible for a property to have no value.
+                return [];
+            }
+
+            var i = 0;
+            var result = [];
+
+            for (; i < len; i++) {
+                result[i] = this._hydrateValue(i);
+            }
+
+            return result;
+        },
+
+        /**
+         * Removes all values from this property
+         */
+        removeAllValues: function () {
+            if (this._values) {
+                this._values.length = 0;
+            }
+            this.jCal.length = 3;
+        },
+
+        /**
+         * Sets the values of the property.  Will overwrite the existing values.
+         * This can only be used for multi-value properties.
+         *
+         * @param {Array} values    An array of values
+         */
+        setValues: function (values) {
+            if (!this.isMultiValue) {
+                throw new Error(
+                    this.name + ': does not not support mulitValue.\n' +
+                    'override isMultiValue'
+                );
+            }
+
+            var len = values.length;
+            var i = 0;
+            this.removeAllValues();
+
+            if (len > 0 &&
+                typeof (values[0]) === 'object' &&
+                'icaltype' in values[0]) {
+                this.resetType(values[0].icaltype);
+            }
+
+            if (this.isDecorated) {
+                for (; i < len; i++) {
+                    this._setDecoratedValue(values[i], i);
+                }
+            } else {
+                for (; i < len; i++) {
+                    this.jCal[VALUE_INDEX + i] = values[i];
+                }
+            }
+        },
+
+        /**
+         * Sets the current value of the property. If this is a multi-value
+         * property, all other values will be removed.
+         *
+         * @param {String|Object} value     New property value.
+         */
+        setValue: function (value) {
+            this.removeAllValues();
+            if (typeof (value) === 'object' && 'icaltype' in value) {
+                this.resetType(value.icaltype);
+            }
+
+            if (this.isDecorated) {
+                this._setDecoratedValue(value, 0);
+            } else {
+                this.jCal[VALUE_INDEX] = value;
+            }
+        },
+
+        /**
+         * Returns the Object representation of this component. The returned object
+         * is a live jCal object and should be cloned if modified.
+         * @return {Object}
+         */
+        toJSON: function () {
+            return this.jCal;
+        },
+
+        /**
+         * The string representation of this component.
+         * @return {String}
+         */
+        toICALString: function () {
+            return ICAL.stringify.property(
+                this.jCal, this._designSet, true
+            );
+        }
+    };
+
+    /**
+     * Create an {@link ICAL.Property} by parsing the passed iCalendar string.
+     *
+     * @param {String} str                        The iCalendar string to parse
+     * @param {ICAL.design.designSet=} designSet  The design data to use for this property
+     * @return {ICAL.Property}                    The created iCalendar property
+     */
+    Property.fromString = function (str, designSet) {
+        return new Property(ICAL.parse.property(str, designSet));
+    };
+
+    return Property;
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * This symbol is further described later on
+ * @ignore
+ */
+ICAL.UtcOffset = (function () {
+
+    /**
+     * @classdesc
+     * This class represents the "duration" value type, with various calculation
+     * and manipulation methods.
+     *
+     * @class
+     * @alias ICAL.UtcOffset
+     * @param {Object} aData          An object with members of the utc offset
+     * @param {Number=} aData.hours   The hours for the utc offset
+     * @param {Number=} aData.minutes The minutes in the utc offset
+     * @param {Number=} aData.factor  The factor for the utc-offset, either -1 or 1
+     */
+    function UtcOffset(aData) {
+        this.fromData(aData);
+    }
+
+    UtcOffset.prototype = {
+
+        /**
+         * The hours in the utc-offset
+         * @type {Number}
+         */
+        hours: 0,
+
+        /**
+         * The minutes in the utc-offset
+         * @type {Number}
+         */
+        minutes: 0,
+
+        /**
+         * The sign of the utc offset, 1 for positive offset, -1 for negative
+         * offsets.
+         * @type {Number}
+         */
+        factor: 1,
+
+        /**
+         * The type name, to be used in the jCal object.
+         * @constant
+         * @type {String}
+         * @default "utc-offset"
+         */
+        icaltype: "utc-offset",
+
+        /**
+         * Returns a clone of the utc offset object.
+         *
+         * @return {ICAL.UtcOffset}     The cloned object
+         */
+        clone: function () {
+            return ICAL.UtcOffset.fromSeconds(this.toSeconds());
+        },
+
+        /**
+         * Sets up the current instance using members from the passed data object.
+         *
+         * @param {Object} aData          An object with members of the utc offset
+         * @param {Number=} aData.hours   The hours for the utc offset
+         * @param {Number=} aData.minutes The minutes in the utc offset
+         * @param {Number=} aData.factor  The factor for the utc-offset, either -1 or 1
+         */
+        fromData: function (aData) {
+            if (aData) {
+                for (var key in aData) {
+                    /* istanbul ignore else */
+                    if (aData.hasOwnProperty(key)) {
+                        this[key] = aData[key];
+                    }
+                }
+            }
+            this._normalize();
+        },
+
+        /**
+         * Sets up the current instance from the given seconds value. The seconds
+         * value is truncated to the minute. Offsets are wrapped when the world
+         * ends, the hour after UTC+14:00 is UTC-12:00.
+         *
+         * @param {Number} aSeconds         The seconds to convert into an offset
+         */
+        fromSeconds: function (aSeconds) {
+            var secs = Math.abs(aSeconds);
+
+            this.factor = aSeconds < 0 ? -1 : 1;
+            this.hours = ICAL.helpers.trunc(secs / 3600);
+
+            secs -= (this.hours * 3600);
+            this.minutes = ICAL.helpers.trunc(secs / 60);
+            return this;
+        },
+
+        /**
+         * Convert the current offset to a value in seconds
+         *
+         * @return {Number}                 The offset in seconds
+         */
+        toSeconds: function () {
+            return this.factor * (60 * this.minutes + 3600 * this.hours);
+        },
+
+        /**
+         * Compare this utc offset with another one.
+         *
+         * @param {ICAL.UtcOffset} other        The other offset to compare with
+         * @return {Number}                     -1, 0 or 1 for less/equal/greater
+         */
+        compare: function icaltime_compare(other) {
+            var a = this.toSeconds();
+            var b = other.toSeconds();
+            return (a > b) - (b > a);
+        },
+
+        _normalize: function () {
+            // Range: 97200 seconds (with 1 hour inbetween)
+            var secs = this.toSeconds();
+            var factor = this.factor;
+            while (secs < -43200) { // = UTC-12:00
+                secs += 97200;
+            }
+            while (secs > 50400) { // = UTC+14:00
+                secs -= 97200;
+            }
+
+            this.fromSeconds(secs);
+
+            // Avoid changing the factor when on zero seconds
+            if (secs == 0) {
+                this.factor = factor;
+            }
+        },
+
+        /**
+         * The iCalendar string representation of this utc-offset.
+         * @return {String}
+         */
+        toICALString: function () {
+            return ICAL.design.icalendar.value['utc-offset'].toICAL(this.toString());
+        },
+
+        /**
+         * The string representation of this utc-offset.
+         * @return {String}
+         */
+        toString: function toString() {
+            return (this.factor == 1 ? "+" : "-") +
+                ICAL.helpers.pad2(this.hours) + ':' +
+                ICAL.helpers.pad2(this.minutes);
+        }
+    };
+
+    /**
+     * Creates a new {@link ICAL.UtcOffset} instance from the passed string.
+     *
+     * @param {String} aString    The string to parse
+     * @return {ICAL.Duration}    The created utc-offset instance
+     */
+    UtcOffset.fromString = function (aString) {
+        // -05:00
+        var options = {};
+        //TODO: support seconds per rfc5545 ?
+        options.factor = (aString[0] === '+') ? 1 : -1;
+        options.hours = ICAL.helpers.strictParseInt(aString.substr(1, 2));
+        options.minutes = ICAL.helpers.strictParseInt(aString.substr(4, 2));
+
+        return new ICAL.UtcOffset(options);
+    };
+
+    /**
+     * Creates a new {@link ICAL.UtcOffset} instance from the passed seconds
+     * value.
+     *
+     * @param {Number} aSeconds       The number of seconds to convert
+     */
+    UtcOffset.fromSeconds = function (aSeconds) {
+        var instance = new UtcOffset();
+        instance.fromSeconds(aSeconds);
+        return instance;
+    };
+
+    return UtcOffset;
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * This symbol is further described later on
+ * @ignore
+ */
+ICAL.Binary = (function () {
+
+    /**
+     * @classdesc
+     * Represents the BINARY value type, which contains extra methods for
+     * encoding and decoding.
+     *
+     * @class
+     * @alias ICAL.Binary
+     * @param {String} aValue     The binary data for this value
+     */
+    function Binary(aValue) {
+        this.value = aValue;
+    }
+
+    Binary.prototype = {
+        /**
+         * The type name, to be used in the jCal object.
+         * @default "binary"
+         * @constant
+         */
+        icaltype: "binary",
+
+        /**
+         * Base64 decode the current value
+         *
+         * @return {String}         The base64-decoded value
+         */
+        decodeValue: function decodeValue() {
+            return this._b64_decode(this.value);
+        },
+
+        /**
+         * Encodes the passed parameter with base64 and sets the internal
+         * value to the result.
+         *
+         * @param {String} aValue      The raw binary value to encode
+         */
+        setEncodedValue: function setEncodedValue(aValue) {
+            this.value = this._b64_encode(aValue);
+        },
+
+        _b64_encode: function base64_encode(data) {
+            // http://kevin.vanzonneveld.net
+            // +   original by: Tyler Akins (http://rumkin.com)
+            // +   improved by: Bayron Guevara
+            // +   improved by: Thunder.m
+            // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+            // +   bugfixed by: Pellentesque Malesuada
+            // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+            // +   improved by: Rafał Kukawski (http://kukawski.pl)
+            // *     example 1: base64_encode('Kevin van Zonneveld');
+            // *     returns 1: 'S2V2aW4gdmFuIFpvbm5ldmVsZA=='
+            // mozilla has this native
+            // - but breaks in 2.0.0.12!
+            //if (typeof this.window['atob'] == 'function') {
+            //    return atob(data);
+            //}
+            var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+                "abcdefghijklmnopqrstuvwxyz0123456789+/=";
+            var o1, o2, o3, h1, h2, h3, h4, bits, i = 0,
+                ac = 0,
+                enc = "",
+                tmp_arr = [];
+
+            if (!data) {
+                return data;
+            }
+
+            do { // pack three octets into four hexets
+                o1 = data.charCodeAt(i++);
+                o2 = data.charCodeAt(i++);
+                o3 = data.charCodeAt(i++);
+
+                bits = o1 << 16 | o2 << 8 | o3;
+
+                h1 = bits >> 18 & 0x3f;
+                h2 = bits >> 12 & 0x3f;
+                h3 = bits >> 6 & 0x3f;
+                h4 = bits & 0x3f;
+
+                // use hexets to index into b64, and append result to encoded string
+                tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
+            } while (i < data.length);
+
+            enc = tmp_arr.join('');
+
+            var r = data.length % 3;
+
+            return (r ? enc.slice(0, r - 3) : enc) + '==='.slice(r || 3);
+
+        },
+
+        _b64_decode: function base64_decode(data) {
+            // http://kevin.vanzonneveld.net
+            // +   original by: Tyler Akins (http://rumkin.com)
+            // +   improved by: Thunder.m
+            // +      input by: Aman Gupta
+            // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+            // +   bugfixed by: Onno Marsman
+            // +   bugfixed by: Pellentesque Malesuada
+            // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+            // +      input by: Brett Zamir (http://brett-zamir.me)
+            // +   bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+            // *     example 1: base64_decode('S2V2aW4gdmFuIFpvbm5ldmVsZA==');
+            // *     returns 1: 'Kevin van Zonneveld'
+            // mozilla has this native
+            // - but breaks in 2.0.0.12!
+            //if (typeof this.window['btoa'] == 'function') {
+            //    return btoa(data);
+            //}
+            var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+                "abcdefghijklmnopqrstuvwxyz0123456789+/=";
+            var o1, o2, o3, h1, h2, h3, h4, bits, i = 0,
+                ac = 0,
+                dec = "",
+                tmp_arr = [];
+
+            if (!data) {
+                return data;
+            }
+
+            data += '';
+
+            do { // unpack four hexets into three octets using index points in b64
+                h1 = b64.indexOf(data.charAt(i++));
+                h2 = b64.indexOf(data.charAt(i++));
+                h3 = b64.indexOf(data.charAt(i++));
+                h4 = b64.indexOf(data.charAt(i++));
+
+                bits = h1 << 18 | h2 << 12 | h3 << 6 | h4;
+
+                o1 = bits >> 16 & 0xff;
+                o2 = bits >> 8 & 0xff;
+                o3 = bits & 0xff;
+
+                if (h3 == 64) {
+                    tmp_arr[ac++] = String.fromCharCode(o1);
+                } else if (h4 == 64) {
+                    tmp_arr[ac++] = String.fromCharCode(o1, o2);
+                } else {
+                    tmp_arr[ac++] = String.fromCharCode(o1, o2, o3);
+                }
+            } while (i < data.length);
+
+            dec = tmp_arr.join('');
+
+            return dec;
+        },
+
+        /**
+         * The string representation of this value
+         * @return {String}
+         */
+        toString: function () {
+            return this.value;
+        }
+    };
+
+    /**
+     * Creates a binary value from the given string.
+     *
+     * @param {String} aString        The binary value string
+     * @return {ICAL.Binary}          The binary value instance
+     */
+    Binary.fromString = function (aString) {
+        return new Binary(aString);
+    };
+
+    return Binary;
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+
+(function () {
+    /**
+     * @classdesc
+     * This class represents the "period" value type, with various calculation
+     * and manipulation methods.
+     *
+     * @description
+     * The passed data object cannot contain both and end date and a duration.
+     *
+     * @class
+     * @param {Object} aData                  An object with members of the period
+     * @param {ICAL.Time=} aData.start        The start of the period
+     * @param {ICAL.Time=} aData.end          The end of the period
+     * @param {ICAL.Duration=} aData.duration The duration of the period
+     */
+    ICAL.Period = function icalperiod(aData) {
+        this.wrappedJSObject = this;
+
+        if (aData && 'start' in aData) {
+            if (aData.start && !(aData.start instanceof ICAL.Time)) {
+                throw new TypeError('.start must be an instance of ICAL.Time');
+            }
+            this.start = aData.start;
+        }
+
+        if (aData && aData.end && aData.duration) {
+            throw new Error('cannot accept both end and duration');
+        }
+
+        if (aData && 'end' in aData) {
+            if (aData.end && !(aData.end instanceof ICAL.Time)) {
+                throw new TypeError('.end must be an instance of ICAL.Time');
+            }
+            this.end = aData.end;
+        }
+
+        if (aData && 'duration' in aData) {
+            if (aData.duration && !(aData.duration instanceof ICAL.Duration)) {
+                throw new TypeError('.duration must be an instance of ICAL.Duration');
+            }
+            this.duration = aData.duration;
+        }
+    };
+
+    ICAL.Period.prototype = {
+
+        /**
+         * The start of the period
+         * @type {ICAL.Time}
+         */
+        start: null,
+
+        /**
+         * The end of the period
+         * @type {ICAL.Time}
+         */
+        end: null,
+
+        /**
+         * The duration of the period
+         * @type {ICAL.Duration}
+         */
+        duration: null,
+
+        /**
+         * The class identifier.
+         * @constant
+         * @type {String}
+         * @default "icalperiod"
+         */
+        icalclass: "icalperiod",
+
+        /**
+         * The type name, to be used in the jCal object.
+         * @constant
+         * @type {String}
+         * @default "period"
+         */
+        icaltype: "period",
+
+        /**
+         * Returns a clone of the duration object.
+         *
+         * @return {ICAL.Period}      The cloned object
+         */
+        clone: function () {
+            return ICAL.Period.fromData({
+                start: this.start ? this.start.clone() : null,
+                end: this.end ? this.end.clone() : null,
+                duration: this.duration ? this.duration.clone() : null
+            });
+        },
+
+        /**
+         * Calculates the duration of the period, either directly or by subtracting
+         * start from end date.
+         *
+         * @return {ICAL.Duration}      The calculated duration
+         */
+        getDuration: function duration() {
+            if (this.duration) {
+                return this.duration;
+            } else {
+                return this.end.subtractDate(this.start);
+            }
+        },
+
+        /**
+         * Calculates the end date of the period, either directly or by adding
+         * duration to start date.
+         *
+         * @return {ICAL.Time}          The calculated end date
+         */
+        getEnd: function () {
+            if (this.end) {
+                return this.end;
+            } else {
+                var end = this.start.clone();
+                end.addDuration(this.duration);
+                return end;
+            }
+        },
+
+        /**
+         * The string representation of this period.
+         * @return {String}
+         */
+        toString: function toString() {
+            return this.start + "/" + (this.end || this.duration);
+        },
+
+        /**
+         * The jCal representation of this period type.
+         * @return {Object}
+         */
+        toJSON: function () {
+            return [this.start.toString(), (this.end || this.duration).toString()];
+        },
+
+        /**
+         * The iCalendar string representation of this period.
+         * @return {String}
+         */
+        toICALString: function () {
+            return this.start.toICALString() + "/" +
+                (this.end || this.duration).toICALString();
+        }
+    };
+
+    /**
+     * Creates a new {@link ICAL.Period} instance from the passed string.
+     *
+     * @param {String} str            The string to parse
+     * @param {ICAL.Property} prop    The property this period will be on
+     * @return {ICAL.Period}          The created period instance
+     */
+    ICAL.Period.fromString = function fromString(str, prop) {
+        var parts = str.split('/');
+
+        if (parts.length !== 2) {
+            throw new Error(
+                'Invalid string value: "' + str + '" must contain a "/" char.'
+            );
+        }
+
+        var options = {
+            start: ICAL.Time.fromDateTimeString(parts[0], prop)
+        };
+
+        var end = parts[1];
+
+        if (ICAL.Duration.isValueString(end)) {
+            options.duration = ICAL.Duration.fromString(end);
+        } else {
+            options.end = ICAL.Time.fromDateTimeString(end, prop);
+        }
+
+        return new ICAL.Period(options);
+    };
+
+    /**
+     * Creates a new {@link ICAL.Period} instance from the given data object.
+     * The passed data object cannot contain both and end date and a duration.
+     *
+     * @param {Object} aData                  An object with members of the period
+     * @param {ICAL.Time=} aData.start        The start of the period
+     * @param {ICAL.Time=} aData.end          The end of the period
+     * @param {ICAL.Duration=} aData.duration The duration of the period
+     * @return {ICAL.Period}                  The period instance
+     */
+    ICAL.Period.fromData = function fromData(aData) {
+        return new ICAL.Period(aData);
+    };
+
+    /**
+     * Returns a new period instance from the given jCal data array. The first
+     * member is always the start date string, the second member is either a
+     * duration or end date string.
+     *
+     * @param {Array<String,String>} aData    The jCal data array
+     * @param {ICAL.Property} aProp           The property this jCal data is on
+     * @param {Boolean} aLenient              If true, data value can be both date and date-time
+     * @return {ICAL.Period}                  The period instance
+     */
+    ICAL.Period.fromJSON = function (aData, aProp, aLenient) {
+        function fromDateOrDateTimeString(aValue, aProp) {
+            if (aLenient) {
+                return ICAL.Time.fromString(aValue, aProp);
+            } else {
+                return ICAL.Time.fromDateTimeString(aValue, aProp);
+            }
+        }
+
+        if (ICAL.Duration.isValueString(aData[1])) {
+            return ICAL.Period.fromData({
+                start: fromDateOrDateTimeString(aData[0], aProp),
+                duration: ICAL.Duration.fromString(aData[1])
+            });
+        } else {
+            return ICAL.Period.fromData({
+                start: fromDateOrDateTimeString(aData[0], aProp),
+                end: fromDateOrDateTimeString(aData[1], aProp)
+            });
+        }
+    };
+})();
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+
+(function () {
+    var DURATION_LETTERS = /([PDWHMTS]{1,1})/;
+
+    /**
+     * @classdesc
+     * This class represents the "duration" value type, with various calculation
+     * and manipulation methods.
+     *
+     * @class
+     * @alias ICAL.Duration
+     * @param {Object} data               An object with members of the duration
+     * @param {Number} data.weeks         Duration in weeks
+     * @param {Number} data.days          Duration in days
+     * @param {Number} data.hours         Duration in hours
+     * @param {Number} data.minutes       Duration in minutes
+     * @param {Number} data.seconds       Duration in seconds
+     * @param {Boolean} data.isNegative   If true, the duration is negative
+     */
+    ICAL.Duration = function icalduration(data) {
+        this.wrappedJSObject = this;
+        this.fromData(data);
+    };
+
+    ICAL.Duration.prototype = {
+        /**
+         * The weeks in this duration
+         * @type {Number}
+         * @default 0
+         */
+        weeks: 0,
+
+        /**
+         * The days in this duration
+         * @type {Number}
+         * @default 0
+         */
+        days: 0,
+
+        /**
+         * The days in this duration
+         * @type {Number}
+         * @default 0
+         */
+        hours: 0,
+
+        /**
+         * The minutes in this duration
+         * @type {Number}
+         * @default 0
+         */
+        minutes: 0,
+
+        /**
+         * The seconds in this duration
+         * @type {Number}
+         * @default 0
+         */
+        seconds: 0,
+
+        /**
+         * The seconds in this duration
+         * @type {Boolean}
+         * @default false
+         */
+        isNegative: false,
+
+        /**
+         * The class identifier.
+         * @constant
+         * @type {String}
+         * @default "icalduration"
+         */
+        icalclass: "icalduration",
+
+        /**
+         * The type name, to be used in the jCal object.
+         * @constant
+         * @type {String}
+         * @default "duration"
+         */
+        icaltype: "duration",
+
+        /**
+         * Returns a clone of the duration object.
+         *
+         * @return {ICAL.Duration}      The cloned object
+         */
+        clone: function clone() {
+            return ICAL.Duration.fromData(this);
+        },
+
+        /**
+         * The duration value expressed as a number of seconds.
+         *
+         * @return {Number}             The duration value in seconds
+         */
+        toSeconds: function toSeconds() {
+            var seconds = this.seconds + 60 * this.minutes + 3600 * this.hours +
+                86400 * this.days + 7 * 86400 * this.weeks;
+            return (this.isNegative ? -seconds : seconds);
+        },
+
+        /**
+         * Reads the passed seconds value into this duration object. Afterwards,
+         * members like {@link ICAL.Duration#days days} and {@link ICAL.Duration#weeks weeks} will be set up
+         * accordingly.
+         *
+         * @param {Number} aSeconds     The duration value in seconds
+         * @return {ICAL.Duration}      Returns this instance
+         */
+        fromSeconds: function fromSeconds(aSeconds) {
+            var secs = Math.abs(aSeconds);
+
+            this.isNegative = (aSeconds < 0);
+            this.days = ICAL.helpers.trunc(secs / 86400);
+
+            // If we have a flat number of weeks, use them.
+            if (this.days % 7 == 0) {
+                this.weeks = this.days / 7;
+                this.days = 0;
+            } else {
+                this.weeks = 0;
+            }
+
+            secs -= (this.days + 7 * this.weeks) * 86400;
+
+            this.hours = ICAL.helpers.trunc(secs / 3600);
+            secs -= this.hours * 3600;
+
+            this.minutes = ICAL.helpers.trunc(secs / 60);
+            secs -= this.minutes * 60;
+
+            this.seconds = secs;
+            return this;
+        },
+
+        /**
+         * Sets up the current instance using members from the passed data object.
+         *
+         * @param {Object} aData               An object with members of the duration
+         * @param {Number} aData.weeks         Duration in weeks
+         * @param {Number} aData.days          Duration in days
+         * @param {Number} aData.hours         Duration in hours
+         * @param {Number} aData.minutes       Duration in minutes
+         * @param {Number} aData.seconds       Duration in seconds
+         * @param {Boolean} aData.isNegative   If true, the duration is negative
+         */
+        fromData: function fromData(aData) {
+            var propsToCopy = ["weeks", "days", "hours",
+                "minutes", "seconds", "isNegative"];
+            for (var key in propsToCopy) {
+                /* istanbul ignore if */
+                if (!propsToCopy.hasOwnProperty(key)) {
+                    continue;
+                }
+                var prop = propsToCopy[key];
+                if (aData && prop in aData) {
+                    this[prop] = aData[prop];
+                } else {
+                    this[prop] = 0;
+                }
+            }
+        },
+
+        /**
+         * Resets the duration instance to the default values, i.e. PT0S
+         */
+        reset: function reset() {
+            this.isNegative = false;
+            this.weeks = 0;
+            this.days = 0;
+            this.hours = 0;
+            this.minutes = 0;
+            this.seconds = 0;
+        },
+
+        /**
+         * Compares the duration instance with another one.
+         *
+         * @param {ICAL.Duration} aOther        The instance to compare with
+         * @return {Number}                     -1, 0 or 1 for less/equal/greater
+         */
+        compare: function compare(aOther) {
+            var thisSeconds = this.toSeconds();
+            var otherSeconds = aOther.toSeconds();
+            return (thisSeconds > otherSeconds) - (thisSeconds < otherSeconds);
+        },
+
+        /**
+         * Normalizes the duration instance. For example, a duration with a value
+         * of 61 seconds will be normalized to 1 minute and 1 second.
+         */
+        normalize: function normalize() {
+            this.fromSeconds(this.toSeconds());
+        },
+
+        /**
+         * The string representation of this duration.
+         * @return {String}
+         */
+        toString: function toString() {
+            if (this.toSeconds() == 0) {
+                return "PT0S";
+            } else {
+                var str = "";
+                if (this.isNegative) str += "-";
+                str += "P";
+                if (this.weeks) str += this.weeks + "W";
+                if (this.days) str += this.days + "D";
+
+                if (this.hours || this.minutes || this.seconds) {
+                    str += "T";
+                    if (this.hours) str += this.hours + "H";
+                    if (this.minutes) str += this.minutes + "M";
+                    if (this.seconds) str += this.seconds + "S";
+                }
+                return str;
+            }
+        },
+
+        /**
+         * The iCalendar string representation of this duration.
+         * @return {String}
+         */
+        toICALString: function () {
+            return this.toString();
+        }
+    };
+
+    /**
+     * Returns a new ICAL.Duration instance from the passed seconds value.
+     *
+     * @param {Number} aSeconds       The seconds to create the instance from
+     * @return {ICAL.Duration}        The newly created duration instance
+     */
+    ICAL.Duration.fromSeconds = function icalduration_from_seconds(aSeconds) {
+        return (new ICAL.Duration()).fromSeconds(aSeconds);
+    };
+
+    /**
+     * Internal helper function to handle a chunk of a duration.
+     *
+     * @param {String} letter type of duration chunk
+     * @param {String} number numeric value or -/+
+     * @param {Object} dict target to assign values to
+     */
+    function parseDurationChunk(letter, number, object) {
+        var type;
+        switch (letter) {
+            case 'P':
+                if (number && number === '-') {
+                    object.isNegative = true;
+                } else {
+                    object.isNegative = false;
+                }
+                // period
+                break;
+            case 'D':
+                type = 'days';
+                break;
+            case 'W':
+                type = 'weeks';
+                break;
+            case 'H':
+                type = 'hours';
+                break;
+            case 'M':
+                type = 'minutes';
+                break;
+            case 'S':
+                type = 'seconds';
+                break;
+            default:
+                // Not a valid chunk
+                return 0;
+        }
+
+        if (type) {
+            if (!number && number !== 0) {
+                throw new Error(
+                    'invalid duration value: Missing number before "' + letter + '"'
+                );
+            }
+            var num = parseInt(number, 10);
+            if (ICAL.helpers.isStrictlyNaN(num)) {
+                throw new Error(
+                    'invalid duration value: Invalid number "' + number + '" before "' + letter + '"'
+                );
+            }
+            object[type] = num;
+        }
+
+        return 1;
+    }
+
+    /**
+     * Checks if the given string is an iCalendar duration value.
+     *
+     * @param {String} value      The raw ical value
+     * @return {Boolean}          True, if the given value is of the
+     *                              duration ical type
+     */
+    ICAL.Duration.isValueString = function (string) {
+        return (string[0] === 'P' || string[1] === 'P');
+    };
+
+    /**
+     * Creates a new {@link ICAL.Duration} instance from the passed string.
+     *
+     * @param {String} aStr       The string to parse
+     * @return {ICAL.Duration}    The created duration instance
+     */
+    ICAL.Duration.fromString = function icalduration_from_string(aStr) {
+        var pos = 0;
+        var dict = Object.create(null);
+        var chunks = 0;
+
+        while ((pos = aStr.search(DURATION_LETTERS)) !== -1) {
+            var type = aStr[pos];
+            var numeric = aStr.substr(0, pos);
+            aStr = aStr.substr(pos + 1);
+
+            chunks += parseDurationChunk(type, numeric, dict);
+        }
+
+        if (chunks < 2) {
+            // There must be at least a chunk with "P" and some unit chunk
+            throw new Error(
+                'invalid duration value: Not enough duration components in "' + aStr + '"'
+            );
+        }
+
+        return new ICAL.Duration(dict);
+    };
+
+    /**
+     * Creates a new ICAL.Duration instance from the given data object.
+     *
+     * @param {Object} aData               An object with members of the duration
+     * @param {Number} aData.weeks         Duration in weeks
+     * @param {Number} aData.days          Duration in days
+     * @param {Number} aData.hours         Duration in hours
+     * @param {Number} aData.minutes       Duration in minutes
+     * @param {Number} aData.seconds       Duration in seconds
+     * @param {Boolean} aData.isNegative   If true, the duration is negative
+     * @return {ICAL.Duration}             The createad duration instance
+     */
+    ICAL.Duration.fromData = function icalduration_from_data(aData) {
+        return new ICAL.Duration(aData);
+    };
+})();
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2012 */
+
+
+
+(function () {
+    var OPTIONS = ["tzid", "location", "tznames",
+        "latitude", "longitude"];
+
+    /**
+     * @classdesc
+     * Timezone representation, created by passing in a tzid and component.
+     *
+     * @example
+     * var vcalendar;
+     * var timezoneComp = vcalendar.getFirstSubcomponent('vtimezone');
+     * var tzid = timezoneComp.getFirstPropertyValue('tzid');
+     *
+     * var timezone = new ICAL.Timezone({
+     *   component: timezoneComp,
+     *   tzid
+     * });
+     *
+     * @class
+     * @param {ICAL.Component|Object} data options for class
+     * @param {String|ICAL.Component} data.component
+     *        If data is a simple object, then this member can be set to either a
+     *        string containing the component data, or an already parsed
+     *        ICAL.Component
+     * @param {String} data.tzid      The timezone identifier
+     * @param {String} data.location  The timezone locationw
+     * @param {String} data.tznames   An alternative string representation of the
+     *                                  timezone
+     * @param {Number} data.latitude  The latitude of the timezone
+     * @param {Number} data.longitude The longitude of the timezone
+     */
+    ICAL.Timezone = function icaltimezone(data) {
+        this.wrappedJSObject = this;
+        this.fromData(data);
+    };
+
+    ICAL.Timezone.prototype = {
+
+        /**
+         * Timezone identifier
+         * @type {String}
+         */
+        tzid: "",
+
+        /**
+         * Timezone location
+         * @type {String}
+         */
+        location: "",
+
+        /**
+         * Alternative timezone name, for the string representation
+         * @type {String}
+         */
+        tznames: "",
+
+        /**
+         * The primary latitude for the timezone.
+         * @type {Number}
+         */
+        latitude: 0.0,
+
+        /**
+         * The primary longitude for the timezone.
+         * @type {Number}
+         */
+        longitude: 0.0,
+
+        /**
+         * The vtimezone component for this timezone.
+         * @type {ICAL.Component}
+         */
+        component: null,
+
+        /**
+         * The year this timezone has been expanded to. All timezone transition
+         * dates until this year are known and can be used for calculation
+         *
+         * @private
+         * @type {Number}
+         */
+        expandedUntilYear: 0,
+
+        /**
+         * The class identifier.
+         * @constant
+         * @type {String}
+         * @default "icaltimezone"
+         */
+        icalclass: "icaltimezone",
+
+        /**
+         * Sets up the current instance using members from the passed data object.
+         *
+         * @param {ICAL.Component|Object} aData options for class
+         * @param {String|ICAL.Component} aData.component
+         *        If aData is a simple object, then this member can be set to either a
+         *        string containing the component data, or an already parsed
+         *        ICAL.Component
+         * @param {String} aData.tzid      The timezone identifier
+         * @param {String} aData.location  The timezone locationw
+         * @param {String} aData.tznames   An alternative string representation of the
+         *                                  timezone
+         * @param {Number} aData.latitude  The latitude of the timezone
+         * @param {Number} aData.longitude The longitude of the timezone
+         */
+        fromData: function fromData(aData) {
+            this.expandedUntilYear = 0;
+            this.changes = [];
+
+            if (aData instanceof ICAL.Component) {
+                // Either a component is passed directly
+                this.component = aData;
+            } else {
+                // Otherwise the component may be in the data object
+                if (aData && "component" in aData) {
+                    if (typeof aData.component == "string") {
+                        // If a string was passed, parse it as a component
+                        var jCal = ICAL.parse(aData.component);
+                        this.component = new ICAL.Component(jCal);
+                    } else if (aData.component instanceof ICAL.Component) {
+                        // If it was a component already, then just set it
+                        this.component = aData.component;
+                    } else {
+                        // Otherwise just null out the component
+                        this.component = null;
+                    }
+                }
+
+                // Copy remaining passed properties
+                for (var key in OPTIONS) {
+                    /* istanbul ignore else */
+                    if (OPTIONS.hasOwnProperty(key)) {
+                        var prop = OPTIONS[key];
+                        if (aData && prop in aData) {
+                            this[prop] = aData[prop];
+                        }
+                    }
+                }
+            }
+
+            // If we have a component but no TZID, attempt to get it from the
+            // component's properties.
+            if (this.component instanceof ICAL.Component && !this.tzid) {
+                this.tzid = this.component.getFirstPropertyValue('tzid');
+            }
+
+            return this;
+        },
+
+        /**
+         * Finds the utcOffset the given time would occur in this timezone.
+         *
+         * @param {ICAL.Time} tt        The time to check for
+         * @return {Number} utc offset in seconds
+         */
+        utcOffset: function utcOffset(tt) {
+            if (this == ICAL.Timezone.utcTimezone || this == ICAL.Timezone.localTimezone) {
+                return 0;
+            }
+
+            this._ensureCoverage(tt.year);
+
+            if (!this.changes.length) {
+                return 0;
+            }
+
+            var tt_change = {
+                year: tt.year,
+                month: tt.month,
+                day: tt.day,
+                hour: tt.hour,
+                minute: tt.minute,
+                second: tt.second
+            };
+
+            var change_num = this._findNearbyChange(tt_change);
+            var change_num_to_use = -1;
+            var step = 1;
+
+            // TODO: replace with bin search?
+            for (; ;) {
+                var change = ICAL.helpers.clone(this.changes[change_num], true);
+                if (change.utcOffset < change.prevUtcOffset) {
+                    ICAL.Timezone.adjust_change(change, 0, 0, 0, change.utcOffset);
+                } else {
+                    ICAL.Timezone.adjust_change(change, 0, 0, 0,
+                        change.prevUtcOffset);
+                }
+
+                var cmp = ICAL.Timezone._compare_change_fn(tt_change, change);
+
+                if (cmp >= 0) {
+                    change_num_to_use = change_num;
+                } else {
+                    step = -1;
+                }
+
+                if (step == -1 && change_num_to_use != -1) {
+                    break;
+                }
+
+                change_num += step;
+
+                if (change_num < 0) {
+                    return 0;
+                }
+
+                if (change_num >= this.changes.length) {
+                    break;
+                }
+            }
+
+            var zone_change = this.changes[change_num_to_use];
+            var utcOffset_change = zone_change.utcOffset - zone_change.prevUtcOffset;
+
+            if (utcOffset_change < 0 && change_num_to_use > 0) {
+                var tmp_change = ICAL.helpers.clone(zone_change, true);
+                ICAL.Timezone.adjust_change(tmp_change, 0, 0, 0,
+                    tmp_change.prevUtcOffset);
+
+                if (ICAL.Timezone._compare_change_fn(tt_change, tmp_change) < 0) {
+                    var prev_zone_change = this.changes[change_num_to_use - 1];
+
+                    var want_daylight = false; // TODO
+
+                    if (zone_change.is_daylight != want_daylight &&
+                        prev_zone_change.is_daylight == want_daylight) {
+                        zone_change = prev_zone_change;
+                    }
+                }
+            }
+
+            // TODO return is_daylight?
+            return zone_change.utcOffset;
+        },
+
+        _findNearbyChange: function icaltimezone_find_nearby_change(change) {
+            // find the closest match
+            var idx = ICAL.helpers.binsearchInsert(
+                this.changes,
+                change,
+                ICAL.Timezone._compare_change_fn
+            );
+
+            if (idx >= this.changes.length) {
+                return this.changes.length - 1;
+            }
+
+            return idx;
+        },
+
+        _ensureCoverage: function (aYear) {
+            if (ICAL.Timezone._minimumExpansionYear == -1) {
+                var today = ICAL.Time.now();
+                ICAL.Timezone._minimumExpansionYear = today.year;
+            }
+
+            var changesEndYear = aYear;
+            if (changesEndYear < ICAL.Timezone._minimumExpansionYear) {
+                changesEndYear = ICAL.Timezone._minimumExpansionYear;
+            }
+
+            changesEndYear += ICAL.Timezone.EXTRA_COVERAGE;
+
+            if (changesEndYear > ICAL.Timezone.MAX_YEAR) {
+                changesEndYear = ICAL.Timezone.MAX_YEAR;
+            }
+
+            if (!this.changes.length || this.expandedUntilYear < aYear) {
+                var subcomps = this.component.getAllSubcomponents();
+                var compLen = subcomps.length;
+                var compIdx = 0;
+
+                for (; compIdx < compLen; compIdx++) {
+                    this._expandComponent(
+                        subcomps[compIdx], changesEndYear, this.changes
+                    );
+                }
+
+                this.changes.sort(ICAL.Timezone._compare_change_fn);
+                this.expandedUntilYear = changesEndYear;
+            }
+        },
+
+        _expandComponent: function (aComponent, aYear, changes) {
+            if (!aComponent.hasProperty("dtstart") ||
+                !aComponent.hasProperty("tzoffsetto") ||
+                !aComponent.hasProperty("tzoffsetfrom")) {
+                return null;
+            }
+
+            var dtstart = aComponent.getFirstProperty("dtstart").getFirstValue();
+            var change;
+
+            function convert_tzoffset(offset) {
+                return offset.factor * (offset.hours * 3600 + offset.minutes * 60);
+            }
+
+            function init_changes() {
+                var changebase = {};
+                changebase.is_daylight = (aComponent.name == "daylight");
+                changebase.utcOffset = convert_tzoffset(
+                    aComponent.getFirstProperty("tzoffsetto").getFirstValue()
+                );
+
+                changebase.prevUtcOffset = convert_tzoffset(
+                    aComponent.getFirstProperty("tzoffsetfrom").getFirstValue()
+                );
+
+                return changebase;
+            }
+
+            if (!aComponent.hasProperty("rrule") && !aComponent.hasProperty("rdate")) {
+                change = init_changes();
+                change.year = dtstart.year;
+                change.month = dtstart.month;
+                change.day = dtstart.day;
+                change.hour = dtstart.hour;
+                change.minute = dtstart.minute;
+                change.second = dtstart.second;
+
+                ICAL.Timezone.adjust_change(change, 0, 0, 0,
+                    -change.prevUtcOffset);
+                changes.push(change);
+            } else {
+                var props = aComponent.getAllProperties("rdate");
+                for (var rdatekey in props) {
+                    /* istanbul ignore if */
+                    if (!props.hasOwnProperty(rdatekey)) {
+                        continue;
+                    }
+                    var rdate = props[rdatekey];
+                    var time = rdate.getFirstValue();
+                    change = init_changes();
+
+                    change.year = time.year;
+                    change.month = time.month;
+                    change.day = time.day;
+
+                    if (time.isDate) {
+                        change.hour = dtstart.hour;
+                        change.minute = dtstart.minute;
+                        change.second = dtstart.second;
+
+                        if (dtstart.zone != ICAL.Timezone.utcTimezone) {
+                            ICAL.Timezone.adjust_change(change, 0, 0, 0,
+                                -change.prevUtcOffset);
+                        }
+                    } else {
+                        change.hour = time.hour;
+                        change.minute = time.minute;
+                        change.second = time.second;
+
+                        if (time.zone != ICAL.Timezone.utcTimezone) {
+                            ICAL.Timezone.adjust_change(change, 0, 0, 0,
+                                -change.prevUtcOffset);
+                        }
+                    }
+
+                    changes.push(change);
+                }
+
+                var rrule = aComponent.getFirstProperty("rrule");
+
+                if (rrule) {
+                    rrule = rrule.getFirstValue();
+                    change = init_changes();
+
+                    if (rrule.until && rrule.until.zone == ICAL.Timezone.utcTimezone) {
+                        rrule.until.adjust(0, 0, 0, change.prevUtcOffset);
+                        rrule.until.zone = ICAL.Timezone.localTimezone;
+                    }
+
+                    var iterator = rrule.iterator(dtstart);
+
+                    var occ;
+                    while ((occ = iterator.next())) {
+                        change = init_changes();
+                        if (occ.year > aYear || !occ) {
+                            break;
+                        }
+
+                        change.year = occ.year;
+                        change.month = occ.month;
+                        change.day = occ.day;
+                        change.hour = occ.hour;
+                        change.minute = occ.minute;
+                        change.second = occ.second;
+                        change.isDate = occ.isDate;
+
+                        ICAL.Timezone.adjust_change(change, 0, 0, 0,
+                            -change.prevUtcOffset);
+                        changes.push(change);
+                    }
+                }
+            }
+
+            return changes;
+        },
+
+        /**
+         * The string representation of this timezone.
+         * @return {String}
+         */
+        toString: function toString() {
+            return (this.tznames ? this.tznames : this.tzid);
+        }
+    };
+
+    ICAL.Timezone._compare_change_fn = function icaltimezone_compare_change_fn(a, b) {
+        if (a.year < b.year) return -1;
+        else if (a.year > b.year) return 1;
+
+        if (a.month < b.month) return -1;
+        else if (a.month > b.month) return 1;
+
+        if (a.day < b.day) return -1;
+        else if (a.day > b.day) return 1;
+
+        if (a.hour < b.hour) return -1;
+        else if (a.hour > b.hour) return 1;
+
+        if (a.minute < b.minute) return -1;
+        else if (a.minute > b.minute) return 1;
+
+        if (a.second < b.second) return -1;
+        else if (a.second > b.second) return 1;
+
+        return 0;
+    };
+
+    /**
+     * Convert the date/time from one zone to the next.
+     *
+     * @param {ICAL.Time} tt                  The time to convert
+     * @param {ICAL.Timezone} from_zone       The source zone to convert from
+     * @param {ICAL.Timezone} to_zone         The target zone to convert to
+     * @return {ICAL.Time}                    The converted date/time object
+     */
+    ICAL.Timezone.convert_time = function icaltimezone_convert_time(tt, from_zone, to_zone) {
+        if (tt.isDate ||
+            from_zone.tzid == to_zone.tzid ||
+            from_zone == ICAL.Timezone.localTimezone ||
+            to_zone == ICAL.Timezone.localTimezone) {
+            tt.zone = to_zone;
+            return tt;
+        }
+
+        var utcOffset = from_zone.utcOffset(tt);
+        tt.adjust(0, 0, 0, - utcOffset);
+
+        utcOffset = to_zone.utcOffset(tt);
+        tt.adjust(0, 0, 0, utcOffset);
+
+        return null;
+    };
+
+    /**
+     * Creates a new ICAL.Timezone instance from the passed data object.
+     *
+     * @param {ICAL.Component|Object} aData options for class
+     * @param {String|ICAL.Component} aData.component
+     *        If aData is a simple object, then this member can be set to either a
+     *        string containing the component data, or an already parsed
+     *        ICAL.Component
+     * @param {String} aData.tzid      The timezone identifier
+     * @param {String} aData.location  The timezone locationw
+     * @param {String} aData.tznames   An alternative string representation of the
+     *                                  timezone
+     * @param {Number} aData.latitude  The latitude of the timezone
+     * @param {Number} aData.longitude The longitude of the timezone
+     */
+    ICAL.Timezone.fromData = function icaltimezone_fromData(aData) {
+        var tt = new ICAL.Timezone();
+        return tt.fromData(aData);
+    };
+
+    /**
+     * The instance describing the UTC timezone
+     * @type {ICAL.Timezone}
+     * @constant
+     * @instance
+     */
+    ICAL.Timezone.utcTimezone = ICAL.Timezone.fromData({
+        tzid: "UTC"
+    });
+
+    /**
+     * The instance describing the local timezone
+     * @type {ICAL.Timezone}
+     * @constant
+     * @instance
+     */
+    ICAL.Timezone.localTimezone = ICAL.Timezone.fromData({
+        tzid: "floating"
+    });
+
+    /**
+     * Adjust a timezone change object.
+     * @private
+     * @param {Object} change     The timezone change object
+     * @param {Number} days       The extra amount of days
+     * @param {Number} hours      The extra amount of hours
+     * @param {Number} minutes    The extra amount of minutes
+     * @param {Number} seconds    The extra amount of seconds
+     */
+    ICAL.Timezone.adjust_change = function icaltimezone_adjust_change(change, days, hours, minutes, seconds) {
+        return ICAL.Time.prototype.adjust.call(
+            change,
+            days,
+            hours,
+            minutes,
+            seconds,
+            change
+        );
+    };
+
+    ICAL.Timezone._minimumExpansionYear = -1;
+    ICAL.Timezone.MAX_YEAR = 2035; // TODO this is because of time_t, which we don't need. Still usefull?
+    ICAL.Timezone.EXTRA_COVERAGE = 5;
+})();
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * This symbol is further described later on
+ * @ignore
+ */
+ICAL.TimezoneService = (function () {
+    var zones;
+
+    /**
+     * @classdesc
+     * Singleton class to contain timezones.  Right now it is all manual registry in
+     * the future we may use this class to download timezone information or handle
+     * loading pre-expanded timezones.
+     *
+     * @namespace
+     * @alias ICAL.TimezoneService
+     */
+    var TimezoneService = {
+        get count() {
+            return Object.keys(zones).length;
+        },
+
+        reset: function () {
+            zones = Object.create(null);
+            var utc = ICAL.Timezone.utcTimezone;
+
+            zones.Z = utc;
+            zones.UTC = utc;
+            zones.GMT = utc;
+        },
+
+        /**
+         * Checks if timezone id has been registered.
+         *
+         * @param {String} tzid     Timezone identifier (e.g. America/Los_Angeles)
+         * @return {Boolean}        False, when not present
+         */
+        has: function (tzid) {
+            return !!zones[tzid];
+        },
+
+        /**
+         * Returns a timezone by its tzid if present.
+         *
+         * @param {String} tzid     Timezone identifier (e.g. America/Los_Angeles)
+         * @return {?ICAL.Timezone} The timezone, or null if not found
+         */
+        get: function (tzid) {
+            return zones[tzid];
+        },
+
+        /**
+         * Registers a timezone object or component.
+         *
+         * @param {String=} name
+         *        The name of the timezone. Defaults to the component's TZID if not
+         *        passed.
+         * @param {ICAL.Component|ICAL.Timezone} zone
+         *        The initialized zone or vtimezone.
+         */
+        register: function (name, timezone) {
+            if (name instanceof ICAL.Component) {
+                if (name.name === 'vtimezone') {
+                    timezone = new ICAL.Timezone(name);
+                    name = timezone.tzid;
+                }
+            }
+
+            if (timezone instanceof ICAL.Timezone) {
+                zones[name] = timezone;
+            } else {
+                throw new TypeError('timezone must be ICAL.Timezone or ICAL.Component');
+            }
+        },
+
+        /**
+         * Removes a timezone by its tzid from the list.
+         *
+         * @param {String} tzid     Timezone identifier (e.g. America/Los_Angeles)
+         * @return {?ICAL.Timezone} The removed timezone, or null if not registered
+         */
+        remove: function (tzid) {
+            return (delete zones[tzid]);
+        }
+    };
+
+    // initialize defaults
+    TimezoneService.reset();
+
+    return TimezoneService;
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+
+(function () {
+
+    /**
+     * @classdesc
+     * iCalendar Time representation (similar to JS Date object).  Fully
+     * independent of system (OS) timezone / time.  Unlike JS Date, the month
+     * January is 1, not zero.
+     *
+     * @example
+     * var time = new ICAL.Time({
+     *   year: 2012,
+     *   month: 10,
+     *   day: 11
+     *   minute: 0,
+     *   second: 0,
+     *   isDate: false
+     * });
+     *
+     *
+     * @alias ICAL.Time
+     * @class
+     * @param {Object} data           Time initialization
+     * @param {Number=} data.year     The year for this date
+     * @param {Number=} data.month    The month for this date
+     * @param {Number=} data.day      The day for this date
+     * @param {Number=} data.hour     The hour for this date
+     * @param {Number=} data.minute   The minute for this date
+     * @param {Number=} data.second   The second for this date
+     * @param {Boolean=} data.isDate  If true, the instance represents a date (as
+     *                                  opposed to a date-time)
+     * @param {ICAL.Timezone} zone timezone this position occurs in
+     */
+    ICAL.Time = function icaltime(data, zone) {
+        this.wrappedJSObject = this;
+        var time = this._time = Object.create(null);
+
+        /* time defaults */
+        time.year = 0;
+        time.month = 1;
+        time.day = 1;
+        time.hour = 0;
+        time.minute = 0;
+        time.second = 0;
+        time.isDate = false;
+
+        this.fromData(data, zone);
+    };
+
+    ICAL.Time._dowCache = {};
+    ICAL.Time._wnCache = {};
+
+    ICAL.Time.prototype = {
+
+        /**
+         * The class identifier.
+         * @constant
+         * @type {String}
+         * @default "icaltime"
+         */
+        icalclass: "icaltime",
+        _cachedUnixTime: null,
+
+        /**
+         * The type name, to be used in the jCal object. This value may change and
+         * is strictly defined by the {@link ICAL.Time#isDate isDate} member.
+         * @readonly
+         * @type {String}
+         * @default "date-time"
+         */
+        get icaltype() {
+            return this.isDate ? 'date' : 'date-time';
+        },
+
+        /**
+         * The timezone for this time.
+         * @type {ICAL.Timezone}
+         */
+        zone: null,
+
+        /**
+         * Internal uses to indicate that a change has been made and the next read
+         * operation must attempt to normalize the value (for example changing the
+         * day to 33).
+         *
+         * @type {Boolean}
+         * @private
+         */
+        _pendingNormalization: false,
+
+        /**
+         * Returns a clone of the time object.
+         *
+         * @return {ICAL.Time}              The cloned object
+         */
+        clone: function () {
+            return new ICAL.Time(this._time, this.zone);
+        },
+
+        /**
+         * Reset the time instance to epoch time
+         */
+        reset: function icaltime_reset() {
+            this.fromData(ICAL.Time.epochTime);
+            this.zone = ICAL.Timezone.utcTimezone;
+        },
+
+        /**
+         * Reset the time instance to the given date/time values.
+         *
+         * @param {Number} year             The year to set
+         * @param {Number} month            The month to set
+         * @param {Number} day              The day to set
+         * @param {Number} hour             The hour to set
+         * @param {Number} minute           The minute to set
+         * @param {Number} second           The second to set
+         * @param {ICAL.Timezone} timezone  The timezone to set
+         */
+        resetTo: function icaltime_resetTo(year, month, day,
+            hour, minute, second, timezone) {
+            this.fromData({
+                year: year,
+                month: month,
+                day: day,
+                hour: hour,
+                minute: minute,
+                second: second,
+                zone: timezone
+            });
+        },
+
+        /**
+         * Set up the current instance from the Javascript date value.
+         *
+         * @param {?Date} aDate     The Javascript Date to read, or null to reset
+         * @param {Boolean} useUTC  If true, the UTC values of the date will be used
+         */
+        fromJSDate: function icaltime_fromJSDate(aDate, useUTC) {
+            if (!aDate) {
+                this.reset();
+            } else {
+                if (useUTC) {
+                    this.zone = ICAL.Timezone.utcTimezone;
+                    this.year = aDate.getUTCFullYear();
+                    this.month = aDate.getUTCMonth() + 1;
+                    this.day = aDate.getUTCDate();
+                    this.hour = aDate.getUTCHours();
+                    this.minute = aDate.getUTCMinutes();
+                    this.second = aDate.getUTCSeconds();
+                } else {
+                    this.zone = ICAL.Timezone.localTimezone;
+                    this.year = aDate.getFullYear();
+                    this.month = aDate.getMonth() + 1;
+                    this.day = aDate.getDate();
+                    this.hour = aDate.getHours();
+                    this.minute = aDate.getMinutes();
+                    this.second = aDate.getSeconds();
+                }
+            }
+            this._cachedUnixTime = null;
+            return this;
+        },
+
+        /**
+         * Sets up the current instance using members from the passed data object.
+         *
+         * @param {Object} aData            Time initialization
+         * @param {Number=} aData.year      The year for this date
+         * @param {Number=} aData.month     The month for this date
+         * @param {Number=} aData.day       The day for this date
+         * @param {Number=} aData.hour      The hour for this date
+         * @param {Number=} aData.minute    The minute for this date
+         * @param {Number=} aData.second    The second for this date
+         * @param {Boolean=} aData.isDate   If true, the instance represents a date
+         *                                    (as opposed to a date-time)
+         * @param {ICAL.Timezone=} aZone    Timezone this position occurs in
+         */
+        fromData: function fromData(aData, aZone) {
+            if (aData) {
+                for (var key in aData) {
+                    /* istanbul ignore else */
+                    if (Object.prototype.hasOwnProperty.call(aData, key)) {
+                        // ical type cannot be set
+                        if (key === 'icaltype') continue;
+                        this[key] = aData[key];
+                    }
+                }
+            }
+
+            if (aZone) {
+                this.zone = aZone;
+            }
+
+            if (aData && !("isDate" in aData)) {
+                this.isDate = !("hour" in aData);
+            } else if (aData && ("isDate" in aData)) {
+                this.isDate = aData.isDate;
+            }
+
+            if (aData && "timezone" in aData) {
+                var zone = ICAL.TimezoneService.get(
+                    aData.timezone
+                );
+
+                this.zone = zone || ICAL.Timezone.localTimezone;
+            }
+
+            if (aData && "zone" in aData) {
+                this.zone = aData.zone;
+            }
+
+            if (!this.zone) {
+                this.zone = ICAL.Timezone.localTimezone;
+            }
+
+            this._cachedUnixTime = null;
+            return this;
+        },
+
+        /**
+         * Calculate the day of week.
+         * @param {ICAL.Time.weekDay=} aWeekStart
+         *        The week start weekday, defaults to SUNDAY
+         * @return {ICAL.Time.weekDay}
+         */
+        dayOfWeek: function icaltime_dayOfWeek(aWeekStart) {
+            var firstDow = aWeekStart || ICAL.Time.SUNDAY;
+            var dowCacheKey = (this.year << 12) + (this.month << 8) + (this.day << 3) + firstDow;
+            if (dowCacheKey in ICAL.Time._dowCache) {
+                return ICAL.Time._dowCache[dowCacheKey];
+            }
+
+            // Using Zeller's algorithm
+            var q = this.day;
+            var m = this.month + (this.month < 3 ? 12 : 0);
+            var Y = this.year - (this.month < 3 ? 1 : 0);
+
+            var h = (q + Y + ICAL.helpers.trunc(((m + 1) * 26) / 10) + ICAL.helpers.trunc(Y / 4));
+            /* istanbul ignore else */
+            if (true /* gregorian */) {
+                h += ICAL.helpers.trunc(Y / 100) * 6 + ICAL.helpers.trunc(Y / 400);
+            } else {
+                h += 5;
+            }
+
+            // Normalize to 1 = wkst
+            h = ((h + 7 - firstDow) % 7) + 1;
+            ICAL.Time._dowCache[dowCacheKey] = h;
+            return h;
+        },
+
+        /**
+         * Calculate the day of year.
+         * @return {Number}
+         */
+        dayOfYear: function dayOfYear() {
+            var is_leap = (ICAL.Time.isLeapYear(this.year) ? 1 : 0);
+            var diypm = ICAL.Time.daysInYearPassedMonth;
+            return diypm[is_leap][this.month - 1] + this.day;
+        },
+
+        /**
+         * Returns a copy of the current date/time, rewound to the start of the
+         * week. The resulting ICAL.Time instance is of icaltype date, even if this
+         * is a date-time.
+         *
+         * @param {ICAL.Time.weekDay=} aWeekStart
+         *        The week start weekday, defaults to SUNDAY
+         * @return {ICAL.Time}      The start of the week (cloned)
+         */
+        startOfWeek: function startOfWeek(aWeekStart) {
+            var firstDow = aWeekStart || ICAL.Time.SUNDAY;
+            var result = this.clone();
+            result.day -= ((this.dayOfWeek() + 7 - firstDow) % 7);
+            result.isDate = true;
+            result.hour = 0;
+            result.minute = 0;
+            result.second = 0;
+            return result;
+        },
+
+        /**
+         * Returns a copy of the current date/time, shifted to the end of the week.
+         * The resulting ICAL.Time instance is of icaltype date, even if this is a
+         * date-time.
+         *
+         * @param {ICAL.Time.weekDay=} aWeekStart
+         *        The week start weekday, defaults to SUNDAY
+         * @return {ICAL.Time}      The end of the week (cloned)
+         */
+        endOfWeek: function endOfWeek(aWeekStart) {
+            var firstDow = aWeekStart || ICAL.Time.SUNDAY;
+            var result = this.clone();
+            result.day += (7 - this.dayOfWeek() + firstDow - ICAL.Time.SUNDAY) % 7;
+            result.isDate = true;
+            result.hour = 0;
+            result.minute = 0;
+            result.second = 0;
+            return result;
+        },
+
+        /**
+         * Returns a copy of the current date/time, rewound to the start of the
+         * month. The resulting ICAL.Time instance is of icaltype date, even if
+         * this is a date-time.
+         *
+         * @return {ICAL.Time}      The start of the month (cloned)
+         */
+        startOfMonth: function startOfMonth() {
+            var result = this.clone();
+            result.day = 1;
+            result.isDate = true;
+            result.hour = 0;
+            result.minute = 0;
+            result.second = 0;
+            return result;
+        },
+
+        /**
+         * Returns a copy of the current date/time, shifted to the end of the
+         * month.  The resulting ICAL.Time instance is of icaltype date, even if
+         * this is a date-time.
+         *
+         * @return {ICAL.Time}      The end of the month (cloned)
+         */
+        endOfMonth: function endOfMonth() {
+            var result = this.clone();
+            result.day = ICAL.Time.daysInMonth(result.month, result.year);
+            result.isDate = true;
+            result.hour = 0;
+            result.minute = 0;
+            result.second = 0;
+            return result;
+        },
+
+        /**
+         * Returns a copy of the current date/time, rewound to the start of the
+         * year. The resulting ICAL.Time instance is of icaltype date, even if
+         * this is a date-time.
+         *
+         * @return {ICAL.Time}      The start of the year (cloned)
+         */
+        startOfYear: function startOfYear() {
+            var result = this.clone();
+            result.day = 1;
+            result.month = 1;
+            result.isDate = true;
+            result.hour = 0;
+            result.minute = 0;
+            result.second = 0;
+            return result;
+        },
+
+        /**
+         * Returns a copy of the current date/time, shifted to the end of the
+         * year.  The resulting ICAL.Time instance is of icaltype date, even if
+         * this is a date-time.
+         *
+         * @return {ICAL.Time}      The end of the year (cloned)
+         */
+        endOfYear: function endOfYear() {
+            var result = this.clone();
+            result.day = 31;
+            result.month = 12;
+            result.isDate = true;
+            result.hour = 0;
+            result.minute = 0;
+            result.second = 0;
+            return result;
+        },
+
+        /**
+         * First calculates the start of the week, then returns the day of year for
+         * this date. If the day falls into the previous year, the day is zero or negative.
+         *
+         * @param {ICAL.Time.weekDay=} aFirstDayOfWeek
+         *        The week start weekday, defaults to SUNDAY
+         * @return {Number}     The calculated day of year
+         */
+        startDoyWeek: function startDoyWeek(aFirstDayOfWeek) {
+            var firstDow = aFirstDayOfWeek || ICAL.Time.SUNDAY;
+            var delta = this.dayOfWeek() - firstDow;
+            if (delta < 0) delta += 7;
+            return this.dayOfYear() - delta;
+        },
+
+        /**
+         * Get the dominical letter for the current year. Letters range from A - G
+         * for common years, and AG to GF for leap years.
+         *
+         * @param {Number} yr           The year to retrieve the letter for
+         * @return {String}             The dominical letter.
+         */
+        getDominicalLetter: function () {
+            return ICAL.Time.getDominicalLetter(this.year);
+        },
+
+        /**
+         * Finds the nthWeekDay relative to the current month (not day).  The
+         * returned value is a day relative the month that this month belongs to so
+         * 1 would indicate the first of the month and 40 would indicate a day in
+         * the following month.
+         *
+         * @param {Number} aDayOfWeek   Day of the week see the day name constants
+         * @param {Number} aPos         Nth occurrence of a given week day values
+         *        of 1 and 0 both indicate the first weekday of that type. aPos may
+         *        be either positive or negative
+         *
+         * @return {Number} numeric value indicating a day relative
+         *                   to the current month of this time object
+         */
+        nthWeekDay: function icaltime_nthWeekDay(aDayOfWeek, aPos) {
+            var daysInMonth = ICAL.Time.daysInMonth(this.month, this.year);
+            var weekday;
+            var pos = aPos;
+
+            var start = 0;
+
+            var otherDay = this.clone();
+
+            if (pos >= 0) {
+                otherDay.day = 1;
+
+                // because 0 means no position has been given
+                // 1 and 0 indicate the same day.
+                if (pos != 0) {
+                    // remove the extra numeric value
+                    pos--;
+                }
+
+                // set current start offset to current day.
+                start = otherDay.day;
+
+                // find the current day of week
+                var startDow = otherDay.dayOfWeek();
+
+                // calculate the difference between current
+                // day of the week and desired day of the week
+                var offset = aDayOfWeek - startDow;
+
+
+                // if the offset goes into the past
+                // week we add 7 so it goes into the next
+                // week. We only want to go forward in time here.
+                if (offset < 0)
+                    // this is really important otherwise we would
+                    // end up with dates from in the past.
+                    offset += 7;
+
+                // add offset to start so start is the same
+                // day of the week as the desired day of week.
+                start += offset;
+
+                // because we are going to add (and multiply)
+                // the numeric value of the day we subtract it
+                // from the start position so not to add it twice.
+                start -= aDayOfWeek;
+
+                // set week day
+                weekday = aDayOfWeek;
+            } else {
+
+                // then we set it to the last day in the current month
+                otherDay.day = daysInMonth;
+
+                // find the ends weekday
+                var endDow = otherDay.dayOfWeek();
+
+                pos++;
+
+                weekday = (endDow - aDayOfWeek);
+
+                if (weekday < 0) {
+                    weekday += 7;
+                }
+
+                weekday = daysInMonth - weekday;
+            }
+
+            weekday += pos * 7;
+
+            return start + weekday;
+        },
+
+        /**
+         * Checks if current time is the nth weekday, relative to the current
+         * month.  Will always return false when rule resolves outside of current
+         * month.
+         *
+         * @param {ICAL.Time.weekDay} aDayOfWeek       Day of week to check
+         * @param {Number} aPos                        Relative position
+         * @return {Boolean}                           True, if it is the nth weekday
+         */
+        isNthWeekDay: function (aDayOfWeek, aPos) {
+            var dow = this.dayOfWeek();
+
+            if (aPos === 0 && dow === aDayOfWeek) {
+                return true;
+            }
+
+            // get pos
+            var day = this.nthWeekDay(aDayOfWeek, aPos);
+
+            if (day === this.day) {
+                return true;
+            }
+
+            return false;
+        },
+
+        /**
+         * Calculates the ISO 8601 week number. The first week of a year is the
+         * week that contains the first Thursday. The year can have 53 weeks, if
+         * January 1st is a Friday.
+         *
+         * Note there are regions where the first week of the year is the one that
+         * starts on January 1st, which may offset the week number. Also, if a
+         * different week start is specified, this will also affect the week
+         * number.
+         *
+         * @see ICAL.Time.weekOneStarts
+         * @param {ICAL.Time.weekDay} aWeekStart        The weekday the week starts with
+         * @return {Number}                             The ISO week number
+         */
+        weekNumber: function weekNumber(aWeekStart) {
+            var wnCacheKey = (this.year << 12) + (this.month << 8) + (this.day << 3) + aWeekStart;
+            if (wnCacheKey in ICAL.Time._wnCache) {
+                return ICAL.Time._wnCache[wnCacheKey];
+            }
+            // This function courtesty of Julian Bucknall, published under the MIT license
+            // http://www.boyet.com/articles/publishedarticles/calculatingtheisoweeknumb.html
+            // plus some fixes to be able to use different week starts.
+            var week1;
+
+            var dt = this.clone();
+            dt.isDate = true;
+            var isoyear = this.year;
+
+            if (dt.month == 12 && dt.day > 25) {
+                week1 = ICAL.Time.weekOneStarts(isoyear + 1, aWeekStart);
+                if (dt.compare(week1) < 0) {
+                    week1 = ICAL.Time.weekOneStarts(isoyear, aWeekStart);
+                } else {
+                    isoyear++;
+                }
+            } else {
+                week1 = ICAL.Time.weekOneStarts(isoyear, aWeekStart);
+                if (dt.compare(week1) < 0) {
+                    week1 = ICAL.Time.weekOneStarts(--isoyear, aWeekStart);
+                }
+            }
+
+            var daysBetween = (dt.subtractDate(week1).toSeconds() / 86400);
+            var answer = ICAL.helpers.trunc(daysBetween / 7) + 1;
+            ICAL.Time._wnCache[wnCacheKey] = answer;
+            return answer;
+        },
+
+        /**
+         * Adds the duration to the current time. The instance is modified in
+         * place.
+         *
+         * @param {ICAL.Duration} aDuration         The duration to add
+         */
+        addDuration: function icaltime_add(aDuration) {
+            var mult = (aDuration.isNegative ? -1 : 1);
+
+            // because of the duration optimizations it is much
+            // more efficient to grab all the values up front
+            // then set them directly (which will avoid a normalization call).
+            // So we don't actually normalize until we need it.
+            var second = this.second;
+            var minute = this.minute;
+            var hour = this.hour;
+            var day = this.day;
+
+            second += mult * aDuration.seconds;
+            minute += mult * aDuration.minutes;
+            hour += mult * aDuration.hours;
+            day += mult * aDuration.days;
+            day += mult * 7 * aDuration.weeks;
+
+            this.second = second;
+            this.minute = minute;
+            this.hour = hour;
+            this.day = day;
+
+            this._cachedUnixTime = null;
+        },
+
+        /**
+         * Subtract the date details (_excluding_ timezone).  Useful for finding
+         * the relative difference between two time objects excluding their
+         * timezone differences.
+         *
+         * @param {ICAL.Time} aDate     The date to substract
+         * @return {ICAL.Duration}      The difference as a duration
+         */
+        subtractDate: function icaltime_subtract(aDate) {
+            var unixTime = this.toUnixTime() + this.utcOffset();
+            var other = aDate.toUnixTime() + aDate.utcOffset();
+            return ICAL.Duration.fromSeconds(unixTime - other);
+        },
+
+        /**
+         * Subtract the date details, taking timezones into account.
+         *
+         * @param {ICAL.Time} aDate  The date to subtract
+         * @return {ICAL.Duration}  The difference in duration
+         */
+        subtractDateTz: function icaltime_subtract_abs(aDate) {
+            var unixTime = this.toUnixTime();
+            var other = aDate.toUnixTime();
+            return ICAL.Duration.fromSeconds(unixTime - other);
+        },
+
+        /**
+         * Compares the ICAL.Time instance with another one.
+         *
+         * @param {ICAL.Duration} aOther        The instance to compare with
+         * @return {Number}                     -1, 0 or 1 for less/equal/greater
+         */
+        compare: function icaltime_compare(other) {
+            var a = this.toUnixTime();
+            var b = other.toUnixTime();
+
+            if (a > b) return 1;
+            if (b > a) return -1;
+            return 0;
+        },
+
+        /**
+         * Compares only the date part of this instance with another one.
+         *
+         * @param {ICAL.Duration} other         The instance to compare with
+         * @param {ICAL.Timezone} tz            The timezone to compare in
+         * @return {Number}                     -1, 0 or 1 for less/equal/greater
+         */
+        compareDateOnlyTz: function icaltime_compareDateOnlyTz(other, tz) {
+            function cmp(attr) {
+                return ICAL.Time._cmp_attr(a, b, attr);
+            }
+            var a = this.convertToZone(tz);
+            var b = other.convertToZone(tz);
+            var rc = 0;
+
+            if ((rc = cmp("year")) != 0) return rc;
+            if ((rc = cmp("month")) != 0) return rc;
+            if ((rc = cmp("day")) != 0) return rc;
+
+            return rc;
+        },
+
+        /**
+         * Convert the instance into another timezone. The returned ICAL.Time
+         * instance is always a copy.
+         *
+         * @param {ICAL.Timezone} zone      The zone to convert to
+         * @return {ICAL.Time}              The copy, converted to the zone
+         */
+        convertToZone: function convertToZone(zone) {
+            var copy = this.clone();
+            var zone_equals = (this.zone.tzid == zone.tzid);
+
+            if (!this.isDate && !zone_equals) {
+                ICAL.Timezone.convert_time(copy, this.zone, zone);
+            }
+
+            copy.zone = zone;
+            return copy;
+        },
+
+        /**
+         * Calculates the UTC offset of the current date/time in the timezone it is
+         * in.
+         *
+         * @return {Number}     UTC offset in seconds
+         */
+        utcOffset: function utc_offset() {
+            if (this.zone == ICAL.Timezone.localTimezone ||
+                this.zone == ICAL.Timezone.utcTimezone) {
+                return 0;
+            } else {
+                return this.zone.utcOffset(this);
+            }
+        },
+
+        /**
+         * Returns an RFC 5545 compliant ical representation of this object.
+         *
+         * @return {String} ical date/date-time
+         */
+        toICALString: function () {
+            var string = this.toString();
+
+            if (string.length > 10) {
+                return ICAL.design.icalendar.value['date-time'].toICAL(string);
+            } else {
+                return ICAL.design.icalendar.value.date.toICAL(string);
+            }
+        },
+
+        /**
+         * The string representation of this date/time, in jCal form
+         * (including : and - separators).
+         * @return {String}
+         */
+        toString: function toString() {
+            var result = this.year + '-' +
+                ICAL.helpers.pad2(this.month) + '-' +
+                ICAL.helpers.pad2(this.day);
+
+            if (!this.isDate) {
+                result += 'T' + ICAL.helpers.pad2(this.hour) + ':' +
+                    ICAL.helpers.pad2(this.minute) + ':' +
+                    ICAL.helpers.pad2(this.second);
+
+                if (this.zone === ICAL.Timezone.utcTimezone) {
+                    result += 'Z';
+                }
+            }
+
+            return result;
+        },
+
+        /**
+         * Converts the current instance to a Javascript date
+         * @return {Date}
+         */
+        toJSDate: function toJSDate() {
+            if (this.zone == ICAL.Timezone.localTimezone) {
+                if (this.isDate) {
+                    return new Date(this.year, this.month - 1, this.day);
+                } else {
+                    return new Date(this.year, this.month - 1, this.day,
+                        this.hour, this.minute, this.second, 0);
+                }
+            } else {
+                return new Date(this.toUnixTime() * 1000);
+            }
+        },
+
+        _normalize: function icaltime_normalize() {
+            var isDate = this._time.isDate;
+            if (this._time.isDate) {
+                this._time.hour = 0;
+                this._time.minute = 0;
+                this._time.second = 0;
+            }
+            this.adjust(0, 0, 0, 0);
+
+            return this;
+        },
+
+        /**
+         * Adjust the date/time by the given offset
+         *
+         * @param {Number} aExtraDays       The extra amount of days
+         * @param {Number} aExtraHours      The extra amount of hours
+         * @param {Number} aExtraMinutes    The extra amount of minutes
+         * @param {Number} aExtraSeconds    The extra amount of seconds
+         * @param {Number=} aTime           The time to adjust, defaults to the
+         *                                    current instance.
+         */
+        adjust: function icaltime_adjust(aExtraDays, aExtraHours,
+            aExtraMinutes, aExtraSeconds, aTime) {
+
+            var minutesOverflow, hoursOverflow,
+                daysOverflow = 0, yearsOverflow = 0;
+
+            var second, minute, hour, day;
+            var daysInMonth;
+
+            var time = aTime || this._time;
+
+            if (!time.isDate) {
+                second = time.second + aExtraSeconds;
+                time.second = second % 60;
+                minutesOverflow = ICAL.helpers.trunc(second / 60);
+                if (time.second < 0) {
+                    time.second += 60;
+                    minutesOverflow--;
+                }
+
+                minute = time.minute + aExtraMinutes + minutesOverflow;
+                time.minute = minute % 60;
+                hoursOverflow = ICAL.helpers.trunc(minute / 60);
+                if (time.minute < 0) {
+                    time.minute += 60;
+                    hoursOverflow--;
+                }
+
+                hour = time.hour + aExtraHours + hoursOverflow;
+
+                time.hour = hour % 24;
+                daysOverflow = ICAL.helpers.trunc(hour / 24);
+                if (time.hour < 0) {
+                    time.hour += 24;
+                    daysOverflow--;
+                }
+            }
+
+
+            // Adjust month and year first, because we need to know what month the day
+            // is in before adjusting it.
+            if (time.month > 12) {
+                yearsOverflow = ICAL.helpers.trunc((time.month - 1) / 12);
+            } else if (time.month < 1) {
+                yearsOverflow = ICAL.helpers.trunc(time.month / 12) - 1;
+            }
+
+            time.year += yearsOverflow;
+            time.month -= 12 * yearsOverflow;
+
+            // Now take care of the days (and adjust month if needed)
+            day = time.day + aExtraDays + daysOverflow;
+
+            if (day > 0) {
+                for (; ;) {
+                    daysInMonth = ICAL.Time.daysInMonth(time.month, time.year);
+                    if (day <= daysInMonth) {
+                        break;
+                    }
+
+                    time.month++;
+                    if (time.month > 12) {
+                        time.year++;
+                        time.month = 1;
+                    }
+
+                    day -= daysInMonth;
+                }
+            } else {
+                while (day <= 0) {
+                    if (time.month == 1) {
+                        time.year--;
+                        time.month = 12;
+                    } else {
+                        time.month--;
+                    }
+
+                    day += ICAL.Time.daysInMonth(time.month, time.year);
+                }
+            }
+
+            time.day = day;
+
+            this._cachedUnixTime = null;
+            return this;
+        },
+
+        /**
+         * Sets up the current instance from unix time, the number of seconds since
+         * January 1st, 1970.
+         *
+         * @param {Number} seconds      The seconds to set up with
+         */
+        fromUnixTime: function fromUnixTime(seconds) {
+            this.zone = ICAL.Timezone.utcTimezone;
+            var epoch = ICAL.Time.epochTime.clone();
+            epoch.adjust(0, 0, 0, seconds);
+
+            this.year = epoch.year;
+            this.month = epoch.month;
+            this.day = epoch.day;
+            this.hour = epoch.hour;
+            this.minute = epoch.minute;
+            this.second = Math.floor(epoch.second);
+
+            this._cachedUnixTime = null;
+        },
+
+        /**
+         * Converts the current instance to seconds since January 1st 1970.
+         *
+         * @return {Number}         Seconds since 1970
+         */
+        toUnixTime: function toUnixTime() {
+            if (this._cachedUnixTime !== null) {
+                return this._cachedUnixTime;
+            }
+            var offset = this.utcOffset();
+
+            // we use the offset trick to ensure
+            // that we are getting the actual UTC time
+            var ms = Date.UTC(
+                this.year,
+                this.month - 1,
+                this.day,
+                this.hour,
+                this.minute,
+                this.second - offset
+            );
+
+            // seconds
+            this._cachedUnixTime = ms / 1000;
+            return this._cachedUnixTime;
+        },
+
+        /**
+         * Converts time to into Object which can be serialized then re-created
+         * using the constructor.
+         *
+         * @example
+         * // toJSON will automatically be called
+         * var json = JSON.stringify(mytime);
+         *
+         * var deserialized = JSON.parse(json);
+         *
+         * var time = new ICAL.Time(deserialized);
+         *
+         * @return {Object}
+         */
+        toJSON: function () {
+            var copy = [
+                'year',
+                'month',
+                'day',
+                'hour',
+                'minute',
+                'second',
+                'isDate'
+            ];
+
+            var result = Object.create(null);
+
+            var i = 0;
+            var len = copy.length;
+            var prop;
+
+            for (; i < len; i++) {
+                prop = copy[i];
+                result[prop] = this[prop];
+            }
+
+            if (this.zone) {
+                result.timezone = this.zone.tzid;
+            }
+
+            return result;
+        }
+
+    };
+
+    (function setupNormalizeAttributes() {
+        // This needs to run before any instances are created!
+        function defineAttr(attr) {
+            Object.defineProperty(ICAL.Time.prototype, attr, {
+                get: function getTimeAttr() {
+                    if (this._pendingNormalization) {
+                        this._normalize();
+                        this._pendingNormalization = false;
+                    }
+
+                    return this._time[attr];
+                },
+                set: function setTimeAttr(val) {
+                    // Check if isDate will be set and if was not set to normalize date.
+                    // This avoids losing days when seconds, minutes and hours are zeroed
+                    // what normalize will do when time is a date.
+                    if (attr === "isDate" && val && !this._time.isDate) {
+                        this.adjust(0, 0, 0, 0);
+                    }
+                    this._cachedUnixTime = null;
+                    this._pendingNormalization = true;
+                    this._time[attr] = val;
+
+                    return val;
+                }
+            });
+
+        }
+
+        /* istanbul ignore else */
+        if ("defineProperty" in Object) {
+            defineAttr("year");
+            defineAttr("month");
+            defineAttr("day");
+            defineAttr("hour");
+            defineAttr("minute");
+            defineAttr("second");
+            defineAttr("isDate");
+        }
+    })();
+
+    /**
+     * Returns the days in the given month
+     *
+     * @param {Number} month      The month to check
+     * @param {Number} year       The year to check
+     * @return {Number}           The number of days in the month
+     */
+    ICAL.Time.daysInMonth = function icaltime_daysInMonth(month, year) {
+        var _daysInMonth = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+        var days = 30;
+
+        if (month < 1 || month > 12) return days;
+
+        days = _daysInMonth[month];
+
+        if (month == 2) {
+            days += ICAL.Time.isLeapYear(year);
+        }
+
+        return days;
+    };
+
+    /**
+     * Checks if the year is a leap year
+     *
+     * @param {Number} year       The year to check
+     * @return {Boolean}          True, if the year is a leap year
+     */
+    ICAL.Time.isLeapYear = function isLeapYear(year) {
+        if (year <= 1752) {
+            return ((year % 4) == 0);
+        } else {
+            return (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0));
+        }
+    };
+
+    /**
+     * Create a new ICAL.Time from the day of year and year. The date is returned
+     * in floating timezone.
+     *
+     * @param {Number} aDayOfYear     The day of year
+     * @param {Number} aYear          The year to create the instance in
+     * @return {ICAL.Time}            The created instance with the calculated date
+     */
+    ICAL.Time.fromDayOfYear = function icaltime_fromDayOfYear(aDayOfYear, aYear) {
+        var year = aYear;
+        var doy = aDayOfYear;
+        var tt = new ICAL.Time();
+        tt.auto_normalize = false;
+        var is_leap = (ICAL.Time.isLeapYear(year) ? 1 : 0);
+
+        if (doy < 1) {
+            year--;
+            is_leap = (ICAL.Time.isLeapYear(year) ? 1 : 0);
+            doy += ICAL.Time.daysInYearPassedMonth[is_leap][12];
+            return ICAL.Time.fromDayOfYear(doy, year);
+        } else if (doy > ICAL.Time.daysInYearPassedMonth[is_leap][12]) {
+            is_leap = (ICAL.Time.isLeapYear(year) ? 1 : 0);
+            doy -= ICAL.Time.daysInYearPassedMonth[is_leap][12];
+            year++;
+            return ICAL.Time.fromDayOfYear(doy, year);
+        }
+
+        tt.year = year;
+        tt.isDate = true;
+
+        for (var month = 11; month >= 0; month--) {
+            if (doy > ICAL.Time.daysInYearPassedMonth[is_leap][month]) {
+                tt.month = month + 1;
+                tt.day = doy - ICAL.Time.daysInYearPassedMonth[is_leap][month];
+                break;
+            }
+        }
+
+        tt.auto_normalize = true;
+        return tt;
+    };
+
+    /**
+     * Returns a new ICAL.Time instance from a date string, e.g 2015-01-02.
+     *
+     * @deprecated                Use {@link ICAL.Time.fromDateString} instead
+     * @param {String} str        The string to create from
+     * @return {ICAL.Time}        The date/time instance
+     */
+    ICAL.Time.fromStringv2 = function fromString(str) {
+        return new ICAL.Time({
+            year: parseInt(str.substr(0, 4), 10),
+            month: parseInt(str.substr(5, 2), 10),
+            day: parseInt(str.substr(8, 2), 10),
+            isDate: true
+        });
+    };
+
+    /**
+     * Returns a new ICAL.Time instance from a date string, e.g 2015-01-02.
+     *
+     * @param {String} aValue     The string to create from
+     * @return {ICAL.Time}        The date/time instance
+     */
+    ICAL.Time.fromDateString = function (aValue) {
+        // Dates should have no timezone.
+        // Google likes to sometimes specify Z on dates
+        // we specifically ignore that to avoid issues.
+
+        // YYYY-MM-DD
+        // 2012-10-10
+        return new ICAL.Time({
+            year: ICAL.helpers.strictParseInt(aValue.substr(0, 4)),
+            month: ICAL.helpers.strictParseInt(aValue.substr(5, 2)),
+            day: ICAL.helpers.strictParseInt(aValue.substr(8, 2)),
+            isDate: true
+        });
+    };
+
+    /**
+     * Returns a new ICAL.Time instance from a date-time string, e.g
+     * 2015-01-02T03:04:05. If a property is specified, the timezone is set up
+     * from the property's TZID parameter.
+     *
+     * @param {String} aValue         The string to create from
+     * @param {ICAL.Property=} prop   The property the date belongs to
+     * @return {ICAL.Time}            The date/time instance
+     */
+    ICAL.Time.fromDateTimeString = function (aValue, prop) {
+        if (aValue.length < 19) {
+            throw new Error(
+                'invalid date-time value: "' + aValue + '"'
+            );
+        }
+
+        var zone;
+
+        if (aValue[19] && aValue[19] === 'Z') {
+            zone = 'Z';
+        } else if (prop) {
+            zone = prop.getParameter('tzid');
+        }
+
+        // 2012-10-10T10:10:10(Z)?
+        var time = new ICAL.Time({
+            year: ICAL.helpers.strictParseInt(aValue.substr(0, 4)),
+            month: ICAL.helpers.strictParseInt(aValue.substr(5, 2)),
+            day: ICAL.helpers.strictParseInt(aValue.substr(8, 2)),
+            hour: ICAL.helpers.strictParseInt(aValue.substr(11, 2)),
+            minute: ICAL.helpers.strictParseInt(aValue.substr(14, 2)),
+            second: ICAL.helpers.strictParseInt(aValue.substr(17, 2)),
+            timezone: zone
+        });
+
+        return time;
+    };
+
+    /**
+     * Returns a new ICAL.Time instance from a date or date-time string,
+     *
+     * @param {String} aValue         The string to create from
+     * @param {ICAL.Property=} prop   The property the date belongs to
+     * @return {ICAL.Time}            The date/time instance
+     */
+    ICAL.Time.fromString = function fromString(aValue, aProperty) {
+        if (aValue.length > 10) {
+            return ICAL.Time.fromDateTimeString(aValue, aProperty);
+        } else {
+            return ICAL.Time.fromDateString(aValue);
+        }
+    };
+
+    /**
+     * Creates a new ICAL.Time instance from the given Javascript Date.
+     *
+     * @param {?Date} aDate     The Javascript Date to read, or null to reset
+     * @param {Boolean} useUTC  If true, the UTC values of the date will be used
+     */
+    ICAL.Time.fromJSDate = function fromJSDate(aDate, useUTC) {
+        var tt = new ICAL.Time();
+        return tt.fromJSDate(aDate, useUTC);
+    };
+
+    /**
+     * Creates a new ICAL.Time instance from the the passed data object.
+     *
+     * @param {Object} aData            Time initialization
+     * @param {Number=} aData.year      The year for this date
+     * @param {Number=} aData.month     The month for this date
+     * @param {Number=} aData.day       The day for this date
+     * @param {Number=} aData.hour      The hour for this date
+     * @param {Number=} aData.minute    The minute for this date
+     * @param {Number=} aData.second    The second for this date
+     * @param {Boolean=} aData.isDate   If true, the instance represents a date
+     *                                    (as opposed to a date-time)
+     * @param {ICAL.Timezone=} aZone    Timezone this position occurs in
+     */
+    ICAL.Time.fromData = function fromData(aData, aZone) {
+        var t = new ICAL.Time();
+        return t.fromData(aData, aZone);
+    };
+
+    /**
+     * Creates a new ICAL.Time instance from the current moment.
+     * The instance is “floating” - has no timezone relation.
+     * To create an instance considering the time zone, call
+     * ICAL.Time.fromJSDate(new Date(), true)
+     * @return {ICAL.Time}
+     */
+    ICAL.Time.now = function icaltime_now() {
+        return ICAL.Time.fromJSDate(new Date(), false);
+    };
+
+    /**
+     * Returns the date on which ISO week number 1 starts.
+     *
+     * @see ICAL.Time#weekNumber
+     * @param {Number} aYear                  The year to search in
+     * @param {ICAL.Time.weekDay=} aWeekStart The week start weekday, used for calculation.
+     * @return {ICAL.Time}                    The date on which week number 1 starts
+     */
+    ICAL.Time.weekOneStarts = function weekOneStarts(aYear, aWeekStart) {
+        var t = ICAL.Time.fromData({
+            year: aYear,
+            month: 1,
+            day: 1,
+            isDate: true
+        });
+
+        var dow = t.dayOfWeek();
+        var wkst = aWeekStart || ICAL.Time.DEFAULT_WEEK_START;
+        if (dow > ICAL.Time.THURSDAY) {
+            t.day += 7;
+        }
+        if (wkst > ICAL.Time.THURSDAY) {
+            t.day -= 7;
+        }
+
+        t.day -= dow - wkst;
+
+        return t;
+    };
+
+    /**
+     * Get the dominical letter for the given year. Letters range from A - G for
+     * common years, and AG to GF for leap years.
+     *
+     * @param {Number} yr           The year to retrieve the letter for
+     * @return {String}             The dominical letter.
+     */
+    ICAL.Time.getDominicalLetter = function (yr) {
+        var LTRS = "GFEDCBA";
+        var dom = (yr + (yr / 4 | 0) + (yr / 400 | 0) - (yr / 100 | 0) - 1) % 7;
+        var isLeap = ICAL.Time.isLeapYear(yr);
+        if (isLeap) {
+            return LTRS[(dom + 6) % 7] + LTRS[dom];
+        } else {
+            return LTRS[dom];
+        }
+    };
+
+    /**
+     * January 1st, 1970 as an ICAL.Time.
+     * @type {ICAL.Time}
+     * @constant
+     * @instance
+     */
+    ICAL.Time.epochTime = ICAL.Time.fromData({
+        year: 1970,
+        month: 1,
+        day: 1,
+        hour: 0,
+        minute: 0,
+        second: 0,
+        isDate: false,
+        timezone: "Z"
+    });
+
+    ICAL.Time._cmp_attr = function _cmp_attr(a, b, attr) {
+        if (a[attr] > b[attr]) return 1;
+        if (a[attr] < b[attr]) return -1;
+        return 0;
+    };
+
+    /**
+     * The days that have passed in the year after a given month. The array has
+     * two members, one being an array of passed days for non-leap years, the
+     * other analog for leap years.
+     * @example
+     * var isLeapYear = ICAL.Time.isLeapYear(year);
+     * var passedDays = ICAL.Time.daysInYearPassedMonth[isLeapYear][month];
+     * @type {Array.<Array.<Number>>}
+     */
+    ICAL.Time.daysInYearPassedMonth = [
+        [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365],
+        [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366]
+    ];
+
+    /**
+     * The weekday, 1 = SUNDAY, 7 = SATURDAY. Access via
+     * ICAL.Time.MONDAY, ICAL.Time.TUESDAY, ...
+     *
+     * @typedef {Number} weekDay
+     * @memberof ICAL.Time
+     */
+
+    ICAL.Time.SUNDAY = 1;
+    ICAL.Time.MONDAY = 2;
+    ICAL.Time.TUESDAY = 3;
+    ICAL.Time.WEDNESDAY = 4;
+    ICAL.Time.THURSDAY = 5;
+    ICAL.Time.FRIDAY = 6;
+    ICAL.Time.SATURDAY = 7;
+
+    /**
+     * The default weekday for the WKST part.
+     * @constant
+     * @default ICAL.Time.MONDAY
+     */
+    ICAL.Time.DEFAULT_WEEK_START = ICAL.Time.MONDAY;
+})();
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2015 */
+
+
+
+(function () {
+
+    /**
+     * Describes a vCard time, which has slight differences to the ICAL.Time.
+     * Properties can be null if not specified, for example for dates with
+     * reduced accuracy or truncation.
+     *
+     * Note that currently not all methods are correctly re-implemented for
+     * VCardTime. For example, comparison will have undefined results when some
+     * members are null.
+     *
+     * Also, normalization is not yet implemented for this class!
+     *
+     * @alias ICAL.VCardTime
+     * @class
+     * @extends {ICAL.Time}
+     * @param {Object} data                           The data for the time instance
+     * @param {Number=} data.year                     The year for this date
+     * @param {Number=} data.month                    The month for this date
+     * @param {Number=} data.day                      The day for this date
+     * @param {Number=} data.hour                     The hour for this date
+     * @param {Number=} data.minute                   The minute for this date
+     * @param {Number=} data.second                   The second for this date
+     * @param {ICAL.Timezone|ICAL.UtcOffset} zone     The timezone to use
+     * @param {String} icaltype                       The type for this date/time object
+     */
+    ICAL.VCardTime = function (data, zone, icaltype) {
+        this.wrappedJSObject = this;
+        var time = this._time = Object.create(null);
+
+        time.year = null;
+        time.month = null;
+        time.day = null;
+        time.hour = null;
+        time.minute = null;
+        time.second = null;
+
+        this.icaltype = icaltype || "date-and-or-time";
+
+        this.fromData(data, zone);
+    };
+    ICAL.helpers.inherits(ICAL.Time, ICAL.VCardTime, /** @lends ICAL.VCardTime */ {
+
+        /**
+         * The class identifier.
+         * @constant
+         * @type {String}
+         * @default "vcardtime"
+         */
+        icalclass: "vcardtime",
+
+        /**
+         * The type name, to be used in the jCal object.
+         * @type {String}
+         * @default "date-and-or-time"
+         */
+        icaltype: "date-and-or-time",
+
+        /**
+         * The timezone. This can either be floating, UTC, or an instance of
+         * ICAL.UtcOffset.
+         * @type {ICAL.Timezone|ICAL.UtcOFfset}
+         */
+        zone: null,
+
+        /**
+         * Returns a clone of the vcard date/time object.
+         *
+         * @return {ICAL.VCardTime}     The cloned object
+         */
+        clone: function () {
+            return new ICAL.VCardTime(this._time, this.zone, this.icaltype);
+        },
+
+        _normalize: function () {
+            return this;
+        },
+
+        /**
+         * @inheritdoc
+         */
+        utcOffset: function () {
+            if (this.zone instanceof ICAL.UtcOffset) {
+                return this.zone.toSeconds();
+            } else {
+                return ICAL.Time.prototype.utcOffset.apply(this, arguments);
+            }
+        },
+
+        /**
+         * Returns an RFC 6350 compliant representation of this object.
+         *
+         * @return {String}         vcard date/time string
+         */
+        toICALString: function () {
+            return ICAL.design.vcard.value[this.icaltype].toICAL(this.toString());
+        },
+
+        /**
+         * The string representation of this date/time, in jCard form
+         * (including : and - separators).
+         * @return {String}
+         */
+        toString: function toString() {
+            var p2 = ICAL.helpers.pad2;
+            var y = this.year, m = this.month, d = this.day;
+            var h = this.hour, mm = this.minute, s = this.second;
+
+            var hasYear = y !== null, hasMonth = m !== null, hasDay = d !== null;
+            var hasHour = h !== null, hasMinute = mm !== null, hasSecond = s !== null;
+
+            var datepart = (hasYear ? p2(y) + (hasMonth || hasDay ? '-' : '') : (hasMonth || hasDay ? '--' : '')) +
+                (hasMonth ? p2(m) : '') +
+                (hasDay ? '-' + p2(d) : '');
+            var timepart = (hasHour ? p2(h) : '-') + (hasHour && hasMinute ? ':' : '') +
+                (hasMinute ? p2(mm) : '') + (!hasHour && !hasMinute ? '-' : '') +
+                (hasMinute && hasSecond ? ':' : '') +
+                (hasSecond ? p2(s) : '');
+
+            var zone;
+            if (this.zone === ICAL.Timezone.utcTimezone) {
+                zone = 'Z';
+            } else if (this.zone instanceof ICAL.UtcOffset) {
+                zone = this.zone.toString();
+            } else if (this.zone === ICAL.Timezone.localTimezone) {
+                zone = '';
+            } else if (this.zone instanceof ICAL.Timezone) {
+                var offset = ICAL.UtcOffset.fromSeconds(this.zone.utcOffset(this));
+                zone = offset.toString();
+            } else {
+                zone = '';
+            }
+
+            switch (this.icaltype) {
+                case "time":
+                    return timepart + zone;
+                case "date-and-or-time":
+                case "date-time":
+                    return datepart + (timepart == '--' ? '' : 'T' + timepart + zone);
+                case "date":
+                    return datepart;
+            }
+            return null;
+        }
+    });
+
+    /**
+     * Returns a new ICAL.VCardTime instance from a date and/or time string.
+     *
+     * @param {String} aValue     The string to create from
+     * @param {String} aIcalType  The type for this instance, e.g. date-and-or-time
+     * @return {ICAL.VCardTime}   The date/time instance
+     */
+    ICAL.VCardTime.fromDateAndOrTimeString = function (aValue, aIcalType) {
+        function part(v, s, e) {
+            return v ? ICAL.helpers.strictParseInt(v.substr(s, e)) : null;
+        }
+        var parts = aValue.split('T');
+        var dt = parts[0], tmz = parts[1];
+        var splitzone = tmz ? ICAL.design.vcard.value.time._splitZone(tmz) : [];
+        var zone = splitzone[0], tm = splitzone[1];
+
+        var stoi = ICAL.helpers.strictParseInt;
+        var dtlen = dt ? dt.length : 0;
+        var tmlen = tm ? tm.length : 0;
+
+        var hasDashDate = dt && dt[0] == '-' && dt[1] == '-';
+        var hasDashTime = tm && tm[0] == '-';
+
+        var o = {
+            year: hasDashDate ? null : part(dt, 0, 4),
+            month: hasDashDate && (dtlen == 4 || dtlen == 7) ? part(dt, 2, 2) : dtlen == 7 ? part(dt, 5, 2) : dtlen == 10 ? part(dt, 5, 2) : null,
+            day: dtlen == 5 ? part(dt, 3, 2) : dtlen == 7 && hasDashDate ? part(dt, 5, 2) : dtlen == 10 ? part(dt, 8, 2) : null,
+
+            hour: hasDashTime ? null : part(tm, 0, 2),
+            minute: hasDashTime && tmlen == 3 ? part(tm, 1, 2) : tmlen > 4 ? hasDashTime ? part(tm, 1, 2) : part(tm, 3, 2) : null,
+            second: tmlen == 4 ? part(tm, 2, 2) : tmlen == 6 ? part(tm, 4, 2) : tmlen == 8 ? part(tm, 6, 2) : null
+        };
+
+        if (zone == 'Z') {
+            zone = ICAL.Timezone.utcTimezone;
+        } else if (zone && zone[3] == ':') {
+            zone = ICAL.UtcOffset.fromString(zone);
+        } else {
+            zone = null;
+        }
+
+        return new ICAL.VCardTime(o, zone, aIcalType);
+    };
+})();
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+
+(function () {
+    var DOW_MAP = {
+        SU: ICAL.Time.SUNDAY,
+        MO: ICAL.Time.MONDAY,
+        TU: ICAL.Time.TUESDAY,
+        WE: ICAL.Time.WEDNESDAY,
+        TH: ICAL.Time.THURSDAY,
+        FR: ICAL.Time.FRIDAY,
+        SA: ICAL.Time.SATURDAY
+    };
+
+    var REVERSE_DOW_MAP = {};
+    for (var key in DOW_MAP) {
+        /* istanbul ignore else */
+        if (DOW_MAP.hasOwnProperty(key)) {
+            REVERSE_DOW_MAP[DOW_MAP[key]] = key;
+        }
+    }
+
+    var COPY_PARTS = ["BYSECOND", "BYMINUTE", "BYHOUR", "BYDAY",
+        "BYMONTHDAY", "BYYEARDAY", "BYWEEKNO",
+        "BYMONTH", "BYSETPOS"];
+
+    /**
+     * @classdesc
+     * This class represents the "recur" value type, with various calculation
+     * and manipulation methods.
+     *
+     * @class
+     * @alias ICAL.Recur
+     * @param {Object} data                               An object with members of the recurrence
+     * @param {ICAL.Recur.frequencyValues=} data.freq     The frequency value
+     * @param {Number=} data.interval                     The INTERVAL value
+     * @param {ICAL.Time.weekDay=} data.wkst              The week start value
+     * @param {ICAL.Time=} data.until                     The end of the recurrence set
+     * @param {Number=} data.count                        The number of occurrences
+     * @param {Array.<Number>=} data.bysecond             The seconds for the BYSECOND part
+     * @param {Array.<Number>=} data.byminute             The minutes for the BYMINUTE part
+     * @param {Array.<Number>=} data.byhour               The hours for the BYHOUR part
+     * @param {Array.<String>=} data.byday                The BYDAY values
+     * @param {Array.<Number>=} data.bymonthday           The days for the BYMONTHDAY part
+     * @param {Array.<Number>=} data.byyearday            The days for the BYYEARDAY part
+     * @param {Array.<Number>=} data.byweekno             The weeks for the BYWEEKNO part
+     * @param {Array.<Number>=} data.bymonth              The month for the BYMONTH part
+     * @param {Array.<Number>=} data.bysetpos             The positionals for the BYSETPOS part
+     */
+    ICAL.Recur = function icalrecur(data) {
+        this.wrappedJSObject = this;
+        this.parts = {};
+
+        if (data && typeof (data) === 'object') {
+            this.fromData(data);
+        }
+    };
+
+    ICAL.Recur.prototype = {
+        /**
+         * An object holding the BY-parts of the recurrence rule
+         * @type {Object}
+         */
+        parts: null,
+
+        /**
+         * The interval value for the recurrence rule.
+         * @type {Number}
+         */
+        interval: 1,
+
+        /**
+         * The week start day
+         *
+         * @type {ICAL.Time.weekDay}
+         * @default ICAL.Time.MONDAY
+         */
+        wkst: ICAL.Time.MONDAY,
+
+        /**
+         * The end of the recurrence
+         * @type {?ICAL.Time}
+         */
+        until: null,
+
+        /**
+         * The maximum number of occurrences
+         * @type {?Number}
+         */
+        count: null,
+
+        /**
+         * The frequency value.
+         * @type {ICAL.Recur.frequencyValues}
+         */
+        freq: null,
+
+        /**
+         * The class identifier.
+         * @constant
+         * @type {String}
+         * @default "icalrecur"
+         */
+        icalclass: "icalrecur",
+
+        /**
+         * The type name, to be used in the jCal object.
+         * @constant
+         * @type {String}
+         * @default "recur"
+         */
+        icaltype: "recur",
+
+        /**
+         * Create a new iterator for this recurrence rule. The passed start date
+         * must be the start date of the event, not the start of the range to
+         * search in.
+         *
+         * @example
+         * var recur = comp.getFirstPropertyValue('rrule');
+         * var dtstart = comp.getFirstPropertyValue('dtstart');
+         * var iter = recur.iterator(dtstart);
+         * for (var next = iter.next(); next; next = iter.next()) {
+         *   if (next.compare(rangeStart) < 0) {
+         *     continue;
+         *   }
+         *   console.log(next.toString());
+         * }
+         *
+         * @param {ICAL.Time} aStart        The item's start date
+         * @return {ICAL.RecurIterator}     The recurrence iterator
+         */
+        iterator: function (aStart) {
+            return new ICAL.RecurIterator({
+                rule: this,
+                dtstart: aStart
+            });
+        },
+
+        /**
+         * Returns a clone of the recurrence object.
+         *
+         * @return {ICAL.Recur}      The cloned object
+         */
+        clone: function clone() {
+            return new ICAL.Recur(this.toJSON());
+        },
+
+        /**
+         * Checks if the current rule is finite, i.e. has a count or until part.
+         *
+         * @return {Boolean}        True, if the rule is finite
+         */
+        isFinite: function isfinite() {
+            return !!(this.count || this.until);
+        },
+
+        /**
+         * Checks if the current rule has a count part, and not limited by an until
+         * part.
+         *
+         * @return {Boolean}        True, if the rule is by count
+         */
+        isByCount: function isbycount() {
+            return !!(this.count && !this.until);
+        },
+
+        /**
+         * Adds a component (part) to the recurrence rule. This is not a component
+         * in the sense of {@link ICAL.Component}, but a part of the recurrence
+         * rule, i.e. BYMONTH.
+         *
+         * @param {String} aType            The name of the component part
+         * @param {Array|String} aValue     The component value
+         */
+        addComponent: function addPart(aType, aValue) {
+            var ucname = aType.toUpperCase();
+            if (ucname in this.parts) {
+                this.parts[ucname].push(aValue);
+            } else {
+                this.parts[ucname] = [aValue];
+            }
+        },
+
+        /**
+         * Sets the component value for the given by-part.
+         *
+         * @param {String} aType        The component part name
+         * @param {Array} aValues       The component values
+         */
+        setComponent: function setComponent(aType, aValues) {
+            this.parts[aType.toUpperCase()] = aValues.slice();
+        },
+
+        /**
+         * Gets (a copy) of the requested component value.
+         *
+         * @param {String} aType        The component part name
+         * @return {Array}              The component part value
+         */
+        getComponent: function getComponent(aType) {
+            var ucname = aType.toUpperCase();
+            return (ucname in this.parts ? this.parts[ucname].slice() : []);
+        },
+
+        /**
+         * Retrieves the next occurrence after the given recurrence id. See the
+         * guide on {@tutorial terminology} for more details.
+         *
+         * NOTE: Currently, this method iterates all occurrences from the start
+         * date. It should not be called in a loop for performance reasons. If you
+         * would like to get more than one occurrence, you can iterate the
+         * occurrences manually, see the example on the
+         * {@link ICAL.Recur#iterator iterator} method.
+         *
+         * @param {ICAL.Time} aStartTime        The start of the event series
+         * @param {ICAL.Time} aRecurrenceId     The date of the last occurrence
+         * @return {ICAL.Time}                  The next occurrence after
+         */
+        getNextOccurrence: function getNextOccurrence(aStartTime, aRecurrenceId) {
+            var iter = this.iterator(aStartTime);
+            var next, cdt;
+
+            do {
+                next = iter.next();
+            } while (next && next.compare(aRecurrenceId) <= 0);
+
+            if (next && aRecurrenceId.zone) {
+                next.zone = aRecurrenceId.zone;
+            }
+
+            return next;
+        },
+
+        /**
+         * Sets up the current instance using members from the passed data object.
+         *
+         * @param {Object} data                               An object with members of the recurrence
+         * @param {ICAL.Recur.frequencyValues=} data.freq     The frequency value
+         * @param {Number=} data.interval                     The INTERVAL value
+         * @param {ICAL.Time.weekDay=} data.wkst              The week start value
+         * @param {ICAL.Time=} data.until                     The end of the recurrence set
+         * @param {Number=} data.count                        The number of occurrences
+         * @param {Array.<Number>=} data.bysecond             The seconds for the BYSECOND part
+         * @param {Array.<Number>=} data.byminute             The minutes for the BYMINUTE part
+         * @param {Array.<Number>=} data.byhour               The hours for the BYHOUR part
+         * @param {Array.<String>=} data.byday                The BYDAY values
+         * @param {Array.<Number>=} data.bymonthday           The days for the BYMONTHDAY part
+         * @param {Array.<Number>=} data.byyearday            The days for the BYYEARDAY part
+         * @param {Array.<Number>=} data.byweekno             The weeks for the BYWEEKNO part
+         * @param {Array.<Number>=} data.bymonth              The month for the BYMONTH part
+         * @param {Array.<Number>=} data.bysetpos             The positionals for the BYSETPOS part
+         */
+        fromData: function (data) {
+            for (var key in data) {
+                var uckey = key.toUpperCase();
+
+                if (uckey in partDesign) {
+                    if (Array.isArray(data[key])) {
+                        this.parts[uckey] = data[key];
+                    } else {
+                        this.parts[uckey] = [data[key]];
+                    }
+                } else {
+                    this[key] = data[key];
+                }
+            }
+
+            if (this.interval && typeof this.interval != "number") {
+                optionDesign.INTERVAL(this.interval, this);
+            }
+
+            if (this.wkst && typeof this.wkst != "number") {
+                this.wkst = ICAL.Recur.icalDayToNumericDay(this.wkst);
+            }
+
+            if (this.until && !(this.until instanceof ICAL.Time)) {
+                this.until = ICAL.Time.fromString(this.until);
+            }
+        },
+
+        /**
+         * The jCal representation of this recurrence type.
+         * @return {Object}
+         */
+        toJSON: function () {
+            var res = Object.create(null);
+            res.freq = this.freq;
+
+            if (this.count) {
+                res.count = this.count;
+            }
+
+            if (this.interval > 1) {
+                res.interval = this.interval;
+            }
+
+            for (var k in this.parts) {
+                /* istanbul ignore if */
+                if (!this.parts.hasOwnProperty(k)) {
+                    continue;
+                }
+                var kparts = this.parts[k];
+                if (Array.isArray(kparts) && kparts.length == 1) {
+                    res[k.toLowerCase()] = kparts[0];
+                } else {
+                    res[k.toLowerCase()] = ICAL.helpers.clone(this.parts[k]);
+                }
+            }
+
+            if (this.until) {
+                res.until = this.until.toString();
+            }
+            if ('wkst' in this && this.wkst !== ICAL.Time.DEFAULT_WEEK_START) {
+                res.wkst = ICAL.Recur.numericDayToIcalDay(this.wkst);
+            }
+            return res;
+        },
+
+        /**
+         * The string representation of this recurrence rule.
+         * @return {String}
+         */
+        toString: function icalrecur_toString() {
+            // TODO retain order
+            var str = "FREQ=" + this.freq;
+            if (this.count) {
+                str += ";COUNT=" + this.count;
+            }
+            if (this.interval > 1) {
+                str += ";INTERVAL=" + this.interval;
+            }
+            for (var k in this.parts) {
+                /* istanbul ignore else */
+                if (this.parts.hasOwnProperty(k)) {
+                    str += ";" + k + "=" + this.parts[k];
+                }
+            }
+            if (this.until) {
+                str += ';UNTIL=' + this.until.toICALString();
+            }
+            if ('wkst' in this && this.wkst !== ICAL.Time.DEFAULT_WEEK_START) {
+                str += ';WKST=' + ICAL.Recur.numericDayToIcalDay(this.wkst);
+            }
+            return str;
+        }
+    };
+
+    function parseNumericValue(type, min, max, value) {
+        var result = value;
+
+        if (value[0] === '+') {
+            result = value.substr(1);
+        }
+
+        result = ICAL.helpers.strictParseInt(result);
+
+        if (min !== undefined && value < min) {
+            throw new Error(
+                type + ': invalid value "' + value + '" must be > ' + min
+            );
+        }
+
+        if (max !== undefined && value > max) {
+            throw new Error(
+                type + ': invalid value "' + value + '" must be < ' + min
+            );
+        }
+
+        return result;
+    }
+
+    /**
+     * Convert an ical representation of a day (SU, MO, etc..)
+     * into a numeric value of that day.
+     *
+     * @param {String} string     The iCalendar day name
+     * @param {ICAL.Time.weekDay=} aWeekStart
+     *        The week start weekday, defaults to SUNDAY
+     * @return {Number}           Numeric value of given day
+     */
+    ICAL.Recur.icalDayToNumericDay = function toNumericDay(string, aWeekStart) {
+        //XXX: this is here so we can deal
+        //     with possibly invalid string values.
+        var firstDow = aWeekStart || ICAL.Time.SUNDAY;
+        return ((DOW_MAP[string] - firstDow + 7) % 7) + 1;
+    };
+
+    /**
+     * Convert a numeric day value into its ical representation (SU, MO, etc..)
+     *
+     * @param {Number} num        Numeric value of given day
+     * @param {ICAL.Time.weekDay=} aWeekStart
+     *        The week start weekday, defaults to SUNDAY
+     * @return {String}           The ICAL day value, e.g SU,MO,...
+     */
+    ICAL.Recur.numericDayToIcalDay = function toIcalDay(num, aWeekStart) {
+        //XXX: this is here so we can deal with possibly invalid number values.
+        //     Also, this allows consistent mapping between day numbers and day
+        //     names for external users.
+        var firstDow = aWeekStart || ICAL.Time.SUNDAY;
+        var dow = (num + firstDow - ICAL.Time.SUNDAY);
+        if (dow > 7) {
+            dow -= 7;
+        }
+        return REVERSE_DOW_MAP[dow];
+    };
+
+    var VALID_DAY_NAMES = /^(SU|MO|TU|WE|TH|FR|SA)$/;
+    var VALID_BYDAY_PART = /^([+-])?(5[0-3]|[1-4][0-9]|[1-9])?(SU|MO|TU|WE|TH|FR|SA)$/;
+
+    /**
+     * Possible frequency values for the FREQ part
+     * (YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, SECONDLY)
+     *
+     * @typedef {String} frequencyValues
+     * @memberof ICAL.Recur
+     */
+
+    var ALLOWED_FREQ = ['SECONDLY', 'MINUTELY', 'HOURLY',
+        'DAILY', 'WEEKLY', 'MONTHLY', 'YEARLY'];
+
+    var optionDesign = {
+        FREQ: function (value, dict, fmtIcal) {
+            // yes this is actually equal or faster then regex.
+            // upside here is we can enumerate the valid values.
+            if (ALLOWED_FREQ.indexOf(value) !== -1) {
+                dict.freq = value;
+            } else {
+                throw new Error(
+                    'invalid frequency "' + value + '" expected: "' +
+                    ALLOWED_FREQ.join(', ') + '"'
+                );
+            }
+        },
+
+        COUNT: function (value, dict, fmtIcal) {
+            dict.count = ICAL.helpers.strictParseInt(value);
+        },
+
+        INTERVAL: function (value, dict, fmtIcal) {
+            dict.interval = ICAL.helpers.strictParseInt(value);
+            if (dict.interval < 1) {
+                // 0 or negative values are not allowed, some engines seem to generate
+                // it though. Assume 1 instead.
+                dict.interval = 1;
+            }
+        },
+
+        UNTIL: function (value, dict, fmtIcal) {
+            if (value.length > 10) {
+                dict.until = ICAL.design.icalendar.value['date-time'].fromICAL(value);
+            } else {
+                dict.until = ICAL.design.icalendar.value.date.fromICAL(value);
+            }
+            if (!fmtIcal) {
+                dict.until = ICAL.Time.fromString(dict.until);
+            }
+        },
+
+        WKST: function (value, dict, fmtIcal) {
+            if (VALID_DAY_NAMES.test(value)) {
+                dict.wkst = ICAL.Recur.icalDayToNumericDay(value);
+            } else {
+                throw new Error('invalid WKST value "' + value + '"');
+            }
+        }
+    };
+
+    var partDesign = {
+        BYSECOND: parseNumericValue.bind(this, 'BYSECOND', 0, 60),
+        BYMINUTE: parseNumericValue.bind(this, 'BYMINUTE', 0, 59),
+        BYHOUR: parseNumericValue.bind(this, 'BYHOUR', 0, 23),
+        BYDAY: function (value) {
+            if (VALID_BYDAY_PART.test(value)) {
+                return value;
+            } else {
+                throw new Error('invalid BYDAY value "' + value + '"');
+            }
+        },
+        BYMONTHDAY: parseNumericValue.bind(this, 'BYMONTHDAY', -31, 31),
+        BYYEARDAY: parseNumericValue.bind(this, 'BYYEARDAY', -366, 366),
+        BYWEEKNO: parseNumericValue.bind(this, 'BYWEEKNO', -53, 53),
+        BYMONTH: parseNumericValue.bind(this, 'BYMONTH', 1, 12),
+        BYSETPOS: parseNumericValue.bind(this, 'BYSETPOS', -366, 366)
+    };
+
+
+    /**
+     * Creates a new {@link ICAL.Recur} instance from the passed string.
+     *
+     * @param {String} string         The string to parse
+     * @return {ICAL.Recur}           The created recurrence instance
+     */
+    ICAL.Recur.fromString = function (string) {
+        var data = ICAL.Recur._stringToData(string, false);
+        return new ICAL.Recur(data);
+    };
+
+    /**
+     * Creates a new {@link ICAL.Recur} instance using members from the passed
+     * data object.
+     *
+     * @param {Object} aData                              An object with members of the recurrence
+     * @param {ICAL.Recur.frequencyValues=} aData.freq    The frequency value
+     * @param {Number=} aData.interval                    The INTERVAL value
+     * @param {ICAL.Time.weekDay=} aData.wkst             The week start value
+     * @param {ICAL.Time=} aData.until                    The end of the recurrence set
+     * @param {Number=} aData.count                       The number of occurrences
+     * @param {Array.<Number>=} aData.bysecond            The seconds for the BYSECOND part
+     * @param {Array.<Number>=} aData.byminute            The minutes for the BYMINUTE part
+     * @param {Array.<Number>=} aData.byhour              The hours for the BYHOUR part
+     * @param {Array.<String>=} aData.byday               The BYDAY values
+     * @param {Array.<Number>=} aData.bymonthday          The days for the BYMONTHDAY part
+     * @param {Array.<Number>=} aData.byyearday           The days for the BYYEARDAY part
+     * @param {Array.<Number>=} aData.byweekno            The weeks for the BYWEEKNO part
+     * @param {Array.<Number>=} aData.bymonth             The month for the BYMONTH part
+     * @param {Array.<Number>=} aData.bysetpos            The positionals for the BYSETPOS part
+     */
+    ICAL.Recur.fromData = function (aData) {
+        return new ICAL.Recur(aData);
+    };
+
+    /**
+     * Converts a recurrence string to a data object, suitable for the fromData
+     * method.
+     *
+     * @param {String} string     The string to parse
+     * @param {Boolean} fmtIcal   If true, the string is considered to be an
+     *                              iCalendar string
+     * @return {ICAL.Recur}       The recurrence instance
+     */
+    ICAL.Recur._stringToData = function (string, fmtIcal) {
+        var dict = Object.create(null);
+
+        // split is slower in FF but fast enough.
+        // v8 however this is faster then manual split?
+        var values = string.split(';');
+        var len = values.length;
+
+        for (var i = 0; i < len; i++) {
+            var parts = values[i].split('=');
+            var ucname = parts[0].toUpperCase();
+            var lcname = parts[0].toLowerCase();
+            var name = (fmtIcal ? lcname : ucname);
+            var value = parts[1];
+
+            if (ucname in partDesign) {
+                var partArr = value.split(',');
+                var partArrIdx = 0;
+                var partArrLen = partArr.length;
+
+                for (; partArrIdx < partArrLen; partArrIdx++) {
+                    partArr[partArrIdx] = partDesign[ucname](partArr[partArrIdx]);
+                }
+                dict[name] = (partArr.length == 1 ? partArr[0] : partArr);
+            } else if (ucname in optionDesign) {
+                optionDesign[ucname](value, dict, fmtIcal);
+            } else {
+                // Don't swallow unknown values. Just set them as they are.
+                dict[lcname] = value;
+            }
+        }
+
+        return dict;
+    };
+})();
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * This symbol is further described later on
+ * @ignore
+ */
+ICAL.RecurIterator = (function () {
+
+    /**
+     * @classdesc
+     * An iterator for a single recurrence rule. This class usually doesn't have
+     * to be instanciated directly, the convenience method
+     * {@link ICAL.Recur#iterator} can be used.
+     *
+     * @description
+     * The options object may contain additional members when resuming iteration from a previous run
+     *
+     * @description
+     * The options object may contain additional members when resuming iteration
+     * from a previous run.
+     *
+     * @class
+     * @alias ICAL.RecurIterator
+     * @param {Object} options                The iterator options
+     * @param {ICAL.Recur} options.rule       The rule to iterate.
+     * @param {ICAL.Time} options.dtstart     The start date of the event.
+     * @param {Boolean=} options.initialized  When true, assume that options are
+     *        from a previously constructed iterator. Initialization will not be
+     *        repeated.
+     */
+    function icalrecur_iterator(options) {
+        this.fromData(options);
+    }
+
+    icalrecur_iterator.prototype = {
+
+        /**
+         * True when iteration is finished.
+         * @type {Boolean}
+         */
+        completed: false,
+
+        /**
+         * The rule that is being iterated
+         * @type {ICAL.Recur}
+         */
+        rule: null,
+
+        /**
+         * The start date of the event being iterated.
+         * @type {ICAL.Time}
+         */
+        dtstart: null,
+
+        /**
+         * The last occurrence that was returned from the
+         * {@link ICAL.RecurIterator#next} method.
+         * @type {ICAL.Time}
+         */
+        last: null,
+
+        /**
+         * The sequence number from the occurrence
+         * @type {Number}
+         */
+        occurrence_number: 0,
+
+        /**
+         * The indices used for the {@link ICAL.RecurIterator#by_data} object.
+         * @type {Object}
+         * @private
+         */
+        by_indices: null,
+
+        /**
+         * If true, the iterator has already been initialized
+         * @type {Boolean}
+         * @private
+         */
+        initialized: false,
+
+        /**
+         * The initializd by-data.
+         * @type {Object}
+         * @private
+         */
+        by_data: null,
+
+        /**
+         * The expanded yeardays
+         * @type {Array}
+         * @private
+         */
+        days: null,
+
+        /**
+         * The index in the {@link ICAL.RecurIterator#days} array.
+         * @type {Number}
+         * @private
+         */
+        days_index: 0,
+
+        /**
+         * Initialize the recurrence iterator from the passed data object. This
+         * method is usually not called directly, you can initialize the iterator
+         * through the constructor.
+         *
+         * @param {Object} options                The iterator options
+         * @param {ICAL.Recur} options.rule       The rule to iterate.
+         * @param {ICAL.Time} options.dtstart     The start date of the event.
+         * @param {Boolean=} options.initialized  When true, assume that options are
+         *        from a previously constructed iterator. Initialization will not be
+         *        repeated.
+         */
+        fromData: function (options) {
+            this.rule = ICAL.helpers.formatClassType(options.rule, ICAL.Recur);
+
+            if (!this.rule) {
+                throw new Error('iterator requires a (ICAL.Recur) rule');
+            }
+
+            this.dtstart = ICAL.helpers.formatClassType(options.dtstart, ICAL.Time);
+
+            if (!this.dtstart) {
+                throw new Error('iterator requires a (ICAL.Time) dtstart');
+            }
+
+            if (options.by_data) {
+                this.by_data = options.by_data;
+            } else {
+                this.by_data = ICAL.helpers.clone(this.rule.parts, true);
+            }
+
+            if (options.occurrence_number)
+                this.occurrence_number = options.occurrence_number;
+
+            this.days = options.days || [];
+            if (options.last) {
+                this.last = ICAL.helpers.formatClassType(options.last, ICAL.Time);
+            }
+
+            this.by_indices = options.by_indices;
+
+            if (!this.by_indices) {
+                this.by_indices = {
+                    "BYSECOND": 0,
+                    "BYMINUTE": 0,
+                    "BYHOUR": 0,
+                    "BYDAY": 0,
+                    "BYMONTH": 0,
+                    "BYWEEKNO": 0,
+                    "BYMONTHDAY": 0
+                };
+            }
+
+            this.initialized = options.initialized || false;
+
+            if (!this.initialized) {
+                this.init();
+            }
+        },
+
+        /**
+         * Intialize the iterator
+         * @private
+         */
+        init: function icalrecur_iterator_init() {
+            this.initialized = true;
+            this.last = this.dtstart.clone();
+            var parts = this.by_data;
+
+            if ("BYDAY" in parts) {
+                // libical does this earlier when the rule is loaded, but we postpone to
+                // now so we can preserve the original order.
+                this.sort_byday_rules(parts.BYDAY);
+            }
+
+            // If the BYYEARDAY appares, no other date rule part may appear
+            if ("BYYEARDAY" in parts) {
+                if ("BYMONTH" in parts || "BYWEEKNO" in parts ||
+                    "BYMONTHDAY" in parts || "BYDAY" in parts) {
+                    throw new Error("Invalid BYYEARDAY rule");
+                }
+            }
+
+            // BYWEEKNO and BYMONTHDAY rule parts may not both appear
+            if ("BYWEEKNO" in parts && "BYMONTHDAY" in parts) {
+                throw new Error("BYWEEKNO does not fit to BYMONTHDAY");
+            }
+
+            // For MONTHLY recurrences (FREQ=MONTHLY) neither BYYEARDAY nor
+            // BYWEEKNO may appear.
+            if (this.rule.freq == "MONTHLY" &&
+                ("BYYEARDAY" in parts || "BYWEEKNO" in parts)) {
+                throw new Error("For MONTHLY recurrences neither BYYEARDAY nor BYWEEKNO may appear");
+            }
+
+            // For WEEKLY recurrences (FREQ=WEEKLY) neither BYMONTHDAY nor
+            // BYYEARDAY may appear.
+            if (this.rule.freq == "WEEKLY" &&
+                ("BYYEARDAY" in parts || "BYMONTHDAY" in parts)) {
+                throw new Error("For WEEKLY recurrences neither BYMONTHDAY nor BYYEARDAY may appear");
+            }
+
+            // BYYEARDAY may only appear in YEARLY rules
+            if (this.rule.freq != "YEARLY" && "BYYEARDAY" in parts) {
+                throw new Error("BYYEARDAY may only appear in YEARLY rules");
+            }
+
+            this.last.second = this.setup_defaults("BYSECOND", "SECONDLY", this.dtstart.second);
+            this.last.minute = this.setup_defaults("BYMINUTE", "MINUTELY", this.dtstart.minute);
+            this.last.hour = this.setup_defaults("BYHOUR", "HOURLY", this.dtstart.hour);
+            this.last.day = this.setup_defaults("BYMONTHDAY", "DAILY", this.dtstart.day);
+            this.last.month = this.setup_defaults("BYMONTH", "MONTHLY", this.dtstart.month);
+
+            if (this.rule.freq == "WEEKLY") {
+                if ("BYDAY" in parts) {
+                    var bydayParts = this.ruleDayOfWeek(parts.BYDAY[0], this.rule.wkst);
+                    var pos = bydayParts[0];
+                    var dow = bydayParts[1];
+                    var wkdy = dow - this.last.dayOfWeek(this.rule.wkst);
+                    if ((this.last.dayOfWeek(this.rule.wkst) < dow && wkdy >= 0) || wkdy < 0) {
+                        // Initial time is after first day of BYDAY data
+                        this.last.day += wkdy;
+                    }
+                } else {
+                    var dayName = ICAL.Recur.numericDayToIcalDay(this.dtstart.dayOfWeek());
+                    parts.BYDAY = [dayName];
+                }
+            }
+
+            if (this.rule.freq == "YEARLY") {
+                for (; ;) {
+                    this.expand_year_days(this.last.year);
+                    if (this.days.length > 0) {
+                        break;
+                    }
+                    this.increment_year(this.rule.interval);
+                }
+
+                this._nextByYearDay();
+            }
+
+            if (this.rule.freq == "MONTHLY" && this.has_by_data("BYDAY")) {
+                var tempLast = null;
+                var initLast = this.last.clone();
+                var daysInMonth = ICAL.Time.daysInMonth(this.last.month, this.last.year);
+
+                // Check every weekday in BYDAY with relative dow and pos.
+                for (var i in this.by_data.BYDAY) {
+                    /* istanbul ignore if */
+                    if (!this.by_data.BYDAY.hasOwnProperty(i)) {
+                        continue;
+                    }
+                    this.last = initLast.clone();
+                    var bydayParts = this.ruleDayOfWeek(this.by_data.BYDAY[i]);
+                    var pos = bydayParts[0];
+                    var dow = bydayParts[1];
+                    var dayOfMonth = this.last.nthWeekDay(dow, pos);
+
+                    // If |pos| >= 6, the byday is invalid for a monthly rule.
+                    if (pos >= 6 || pos <= -6) {
+                        throw new Error("Malformed values in BYDAY part");
+                    }
+
+                    // If a Byday with pos=+/-5 is not in the current month it
+                    // must be searched in the next months.
+                    if (dayOfMonth > daysInMonth || dayOfMonth <= 0) {
+                        // Skip if we have already found a "last" in this month.
+                        if (tempLast && tempLast.month == initLast.month) {
+                            continue;
+                        }
+                        while (dayOfMonth > daysInMonth || dayOfMonth <= 0) {
+                            this.increment_month();
+                            daysInMonth = ICAL.Time.daysInMonth(this.last.month, this.last.year);
+                            dayOfMonth = this.last.nthWeekDay(dow, pos);
+                        }
+                    }
+
+                    this.last.day = dayOfMonth;
+                    if (!tempLast || this.last.compare(tempLast) < 0) {
+                        tempLast = this.last.clone();
+                    }
+                }
+                this.last = tempLast.clone();
+
+                //XXX: This feels like a hack, but we need to initialize
+                //     the BYMONTHDAY case correctly and byDayAndMonthDay handles
+                //     this case. It accepts a special flag which will avoid incrementing
+                //     the initial value without the flag days that match the start time
+                //     would be missed.
+                if (this.has_by_data('BYMONTHDAY')) {
+                    this._byDayAndMonthDay(true);
+                }
+
+                if (this.last.day > daysInMonth || this.last.day == 0) {
+                    throw new Error("Malformed values in BYDAY part");
+                }
+
+            } else if (this.has_by_data("BYMONTHDAY")) {
+                if (this.last.day < 0) {
+                    var daysInMonth = ICAL.Time.daysInMonth(this.last.month, this.last.year);
+                    this.last.day = daysInMonth + this.last.day + 1;
+                }
+            }
+
+        },
+
+        /**
+         * Retrieve the next occurrence from the iterator.
+         * @return {ICAL.Time}
+         */
+        next: function icalrecur_iterator_next() {
+            var before = (this.last ? this.last.clone() : null);
+
+            if ((this.rule.count && this.occurrence_number >= this.rule.count) ||
+                (this.rule.until && this.last.compare(this.rule.until) > 0)) {
+
+                //XXX: right now this is just a flag and has no impact
+                //     we can simplify the above case to check for completed later.
+                this.completed = true;
+
+                return null;
+            }
+
+            if (this.occurrence_number == 0 && this.last.compare(this.dtstart) >= 0) {
+                // First of all, give the instance that was initialized
+                this.occurrence_number++;
+                return this.last;
+            }
+
+
+            var valid;
+            do {
+                valid = 1;
+
+                switch (this.rule.freq) {
+                    case "SECONDLY":
+                        this.next_second();
+                        break;
+                    case "MINUTELY":
+                        this.next_minute();
+                        break;
+                    case "HOURLY":
+                        this.next_hour();
+                        break;
+                    case "DAILY":
+                        this.next_day();
+                        break;
+                    case "WEEKLY":
+                        this.next_week();
+                        break;
+                    case "MONTHLY":
+                        valid = this.next_month();
+                        break;
+                    case "YEARLY":
+                        this.next_year();
+                        break;
+
+                    default:
+                        return null;
+                }
+            } while (!this.check_contracting_rules() ||
+            this.last.compare(this.dtstart) < 0 ||
+                !valid);
+
+            // TODO is this valid?
+            if (this.last.compare(before) == 0) {
+                throw new Error("Same occurrence found twice, protecting " +
+                    "you from death by recursion");
+            }
+
+            if (this.rule.until && this.last.compare(this.rule.until) > 0) {
+                this.completed = true;
+                return null;
+            } else {
+                this.occurrence_number++;
+                return this.last;
+            }
+        },
+
+        next_second: function next_second() {
+            return this.next_generic("BYSECOND", "SECONDLY", "second", "minute");
+        },
+
+        increment_second: function increment_second(inc) {
+            return this.increment_generic(inc, "second", 60, "minute");
+        },
+
+        next_minute: function next_minute() {
+            return this.next_generic("BYMINUTE", "MINUTELY",
+                "minute", "hour", "next_second");
+        },
+
+        increment_minute: function increment_minute(inc) {
+            return this.increment_generic(inc, "minute", 60, "hour");
+        },
+
+        next_hour: function next_hour() {
+            return this.next_generic("BYHOUR", "HOURLY", "hour",
+                "monthday", "next_minute");
+        },
+
+        increment_hour: function increment_hour(inc) {
+            this.increment_generic(inc, "hour", 24, "monthday");
+        },
+
+        next_day: function next_day() {
+            var has_by_day = ("BYDAY" in this.by_data);
+            var this_freq = (this.rule.freq == "DAILY");
+
+            if (this.next_hour() == 0) {
+                return 0;
+            }
+
+            if (this_freq) {
+                this.increment_monthday(this.rule.interval);
+            } else {
+                this.increment_monthday(1);
+            }
+
+            return 0;
+        },
+
+        next_week: function next_week() {
+            var end_of_data = 0;
+
+            if (this.next_weekday_by_week() == 0) {
+                return end_of_data;
+            }
+
+            if (this.has_by_data("BYWEEKNO")) {
+                var idx = ++this.by_indices.BYWEEKNO;
+
+                if (this.by_indices.BYWEEKNO == this.by_data.BYWEEKNO.length) {
+                    this.by_indices.BYWEEKNO = 0;
+                    end_of_data = 1;
+                }
+
+                // HACK should be first month of the year
+                this.last.month = 1;
+                this.last.day = 1;
+
+                var week_no = this.by_data.BYWEEKNO[this.by_indices.BYWEEKNO];
+
+                this.last.day += 7 * week_no;
+
+                if (end_of_data) {
+                    this.increment_year(1);
+                }
+            } else {
+                // Jump to the next week
+                this.increment_monthday(7 * this.rule.interval);
+            }
+
+            return end_of_data;
+        },
+
+        /**
+         * Normalize each by day rule for a given year/month.
+         * Takes into account ordering and negative rules
+         *
+         * @private
+         * @param {Number} year         Current year.
+         * @param {Number} month        Current month.
+         * @param {Array}  rules        Array of rules.
+         *
+         * @return {Array} sorted and normalized rules.
+         *                 Negative rules will be expanded to their
+         *                 correct positive values for easier processing.
+         */
+        normalizeByMonthDayRules: function (year, month, rules) {
+            var daysInMonth = ICAL.Time.daysInMonth(month, year);
+
+            // XXX: This is probably bad for performance to allocate
+            //      a new array for each month we scan, if possible
+            //      we should try to optimize this...
+            var newRules = [];
+
+            var ruleIdx = 0;
+            var len = rules.length;
+            var rule;
+
+            for (; ruleIdx < len; ruleIdx++) {
+                rule = rules[ruleIdx];
+
+                // if this rule falls outside of given
+                // month discard it.
+                if (Math.abs(rule) > daysInMonth) {
+                    continue;
+                }
+
+                // negative case
+                if (rule < 0) {
+                    // we add (not subtract it is a negative number)
+                    // one from the rule because 1 === last day of month
+                    rule = daysInMonth + (rule + 1);
+                } else if (rule === 0) {
+                    // skip zero: it is invalid.
+                    continue;
+                }
+
+                // only add unique items...
+                if (newRules.indexOf(rule) === -1) {
+                    newRules.push(rule);
+                }
+
+            }
+
+            // unique and sort
+            return newRules.sort(function (a, b) { return a - b; });
+        },
+
+        /**
+         * NOTES:
+         * We are given a list of dates in the month (BYMONTHDAY) (23, etc..)
+         * Also we are given a list of days (BYDAY) (MO, 2SU, etc..) when
+         * both conditions match a given date (this.last.day) iteration stops.
+         *
+         * @private
+         * @param {Boolean=} isInit     When given true will not increment the
+         *                                current day (this.last).
+         */
+        _byDayAndMonthDay: function (isInit) {
+            var byMonthDay; // setup in initMonth
+            var byDay = this.by_data.BYDAY;
+
+            var date;
+            var dateIdx = 0;
+            var dateLen; // setup in initMonth
+            var dayLen = byDay.length;
+
+            // we are not valid by default
+            var dataIsValid = 0;
+
+            var daysInMonth;
+            var self = this;
+            // we need a copy of this, because a DateTime gets normalized
+            // automatically if the day is out of range. At some points we
+            // set the last day to 0 to start counting.
+            var lastDay = this.last.day;
+
+            function initMonth() {
+                daysInMonth = ICAL.Time.daysInMonth(
+                    self.last.month, self.last.year
+                );
+
+                byMonthDay = self.normalizeByMonthDayRules(
+                    self.last.year,
+                    self.last.month,
+                    self.by_data.BYMONTHDAY
+                );
+
+                dateLen = byMonthDay.length;
+
+                // For the case of more than one occurrence in one month
+                // we have to be sure to start searching after the last
+                // found date or at the last BYMONTHDAY, unless we are
+                // initializing the iterator because in this case we have
+                // to consider the last found date too.
+                while (byMonthDay[dateIdx] <= lastDay &&
+                    !(isInit && byMonthDay[dateIdx] == lastDay) &&
+                    dateIdx < dateLen - 1) {
+                    dateIdx++;
+                }
+            }
+
+            function nextMonth() {
+                // since the day is incremented at the start
+                // of the loop below, we need to start at 0
+                lastDay = 0;
+                self.increment_month();
+                dateIdx = 0;
+                initMonth();
+            }
+
+            initMonth();
+
+            // should come after initMonth
+            if (isInit) {
+                lastDay -= 1;
+            }
+
+            // Use a counter to avoid an infinite loop with malformed rules.
+            // Stop checking after 4 years so we consider also a leap year.
+            var monthsCounter = 48;
+
+            while (!dataIsValid && monthsCounter) {
+                monthsCounter--;
+                // increment the current date. This is really
+                // important otherwise we may fall into the infinite
+                // loop trap. The initial date takes care of the case
+                // where the current date is the date we are looking
+                // for.
+                date = lastDay + 1;
+
+                if (date > daysInMonth) {
+                    nextMonth();
+                    continue;
+                }
+
+                // find next date
+                var next = byMonthDay[dateIdx++];
+
+                // this logic is dependant on the BYMONTHDAYS
+                // being in order (which is done by #normalizeByMonthDayRules)
+                if (next >= date) {
+                    // if the next month day is in the future jump to it.
+                    lastDay = next;
+                } else {
+                    // in this case the 'next' monthday has past
+                    // we must move to the month.
+                    nextMonth();
+                    continue;
+                }
+
+                // Now we can loop through the day rules to see
+                // if one matches the current month date.
+                for (var dayIdx = 0; dayIdx < dayLen; dayIdx++) {
+                    var parts = this.ruleDayOfWeek(byDay[dayIdx]);
+                    var pos = parts[0];
+                    var dow = parts[1];
+
+                    this.last.day = lastDay;
+                    if (this.last.isNthWeekDay(dow, pos)) {
+                        // when we find the valid one we can mark
+                        // the conditions as met and break the loop.
+                        // (Because we have this condition above
+                        //  it will also break the parent loop).
+                        dataIsValid = 1;
+                        break;
+                    }
+                }
+
+                // It is completely possible that the combination
+                // cannot be matched in the current month.
+                // When we reach the end of possible combinations
+                // in the current month we iterate to the next one.
+                // since dateIdx is incremented right after getting
+                // "next", we don't need dateLen -1 here.
+                if (!dataIsValid && dateIdx === dateLen) {
+                    nextMonth();
+                    continue;
+                }
+            }
+
+            if (monthsCounter <= 0) {
+                // Checked 4 years without finding a Byday that matches
+                // a Bymonthday. Maybe the rule is not correct.
+                throw new Error("Malformed values in BYDAY combined with BYMONTHDAY parts");
+            }
+
+
+            return dataIsValid;
+        },
+
+        next_month: function next_month() {
+            var this_freq = (this.rule.freq == "MONTHLY");
+            var data_valid = 1;
+
+            if (this.next_hour() == 0) {
+                return data_valid;
+            }
+
+            if (this.has_by_data("BYDAY") && this.has_by_data("BYMONTHDAY")) {
+                data_valid = this._byDayAndMonthDay();
+            } else if (this.has_by_data("BYDAY")) {
+                var daysInMonth = ICAL.Time.daysInMonth(this.last.month, this.last.year);
+                var setpos = 0;
+                var setpos_total = 0;
+
+                if (this.has_by_data("BYSETPOS")) {
+                    var last_day = this.last.day;
+                    for (var day = 1; day <= daysInMonth; day++) {
+                        this.last.day = day;
+                        if (this.is_day_in_byday(this.last)) {
+                            setpos_total++;
+                            if (day <= last_day) {
+                                setpos++;
+                            }
+                        }
+                    }
+                    this.last.day = last_day;
+                }
+
+                data_valid = 0;
+                for (var day = this.last.day + 1; day <= daysInMonth; day++) {
+                    this.last.day = day;
+
+                    if (this.is_day_in_byday(this.last)) {
+                        if (!this.has_by_data("BYSETPOS") ||
+                            this.check_set_position(++setpos) ||
+                            this.check_set_position(setpos - setpos_total - 1)) {
+
+                            data_valid = 1;
+                            break;
+                        }
+                    }
+                }
+
+                if (day > daysInMonth) {
+                    this.last.day = 1;
+                    this.increment_month();
+
+                    if (this.is_day_in_byday(this.last)) {
+                        if (!this.has_by_data("BYSETPOS") || this.check_set_position(1)) {
+                            data_valid = 1;
+                        }
+                    } else {
+                        data_valid = 0;
+                    }
+                }
+            } else if (this.has_by_data("BYMONTHDAY")) {
+                this.by_indices.BYMONTHDAY++;
+
+                if (this.by_indices.BYMONTHDAY >= this.by_data.BYMONTHDAY.length) {
+                    this.by_indices.BYMONTHDAY = 0;
+                    this.increment_month();
+                }
+
+                var daysInMonth = ICAL.Time.daysInMonth(this.last.month, this.last.year);
+                var day = this.by_data.BYMONTHDAY[this.by_indices.BYMONTHDAY];
+
+                if (day < 0) {
+                    day = daysInMonth + day + 1;
+                }
+
+                if (day > daysInMonth) {
+                    this.last.day = 1;
+                    data_valid = this.is_day_in_byday(this.last);
+                } else {
+                    this.last.day = day;
+                }
+
+            } else {
+                this.increment_month();
+                var daysInMonth = ICAL.Time.daysInMonth(this.last.month, this.last.year);
+                if (this.by_data.BYMONTHDAY[0] > daysInMonth) {
+                    data_valid = 0;
+                } else {
+                    this.last.day = this.by_data.BYMONTHDAY[0];
+                }
+            }
+
+            return data_valid;
+        },
+
+        next_weekday_by_week: function next_weekday_by_week() {
+            var end_of_data = 0;
+
+            if (this.next_hour() == 0) {
+                return end_of_data;
+            }
+
+            if (!this.has_by_data("BYDAY")) {
+                return 1;
+            }
+
+            for (; ;) {
+                var tt = new ICAL.Time();
+                this.by_indices.BYDAY++;
+
+                if (this.by_indices.BYDAY == Object.keys(this.by_data.BYDAY).length) {
+                    this.by_indices.BYDAY = 0;
+                    end_of_data = 1;
+                }
+
+                var coded_day = this.by_data.BYDAY[this.by_indices.BYDAY];
+                var parts = this.ruleDayOfWeek(coded_day);
+                var dow = parts[1];
+
+                dow -= this.rule.wkst;
+
+                if (dow < 0) {
+                    dow += 7;
+                }
+
+                tt.year = this.last.year;
+                tt.month = this.last.month;
+                tt.day = this.last.day;
+
+                var startOfWeek = tt.startDoyWeek(this.rule.wkst);
+
+                if (dow + startOfWeek < 1) {
+                    // The selected date is in the previous year
+                    if (!end_of_data) {
+                        continue;
+                    }
+                }
+
+                var next = ICAL.Time.fromDayOfYear(startOfWeek + dow,
+                    this.last.year);
+
+                /**
+                 * The normalization horrors below are due to
+                 * the fact that when the year/month/day changes
+                 * it can effect the other operations that come after.
+                 */
+                this.last.year = next.year;
+                this.last.month = next.month;
+                this.last.day = next.day;
+
+                return end_of_data;
+            }
+        },
+
+        next_year: function next_year() {
+
+            if (this.next_hour() == 0) {
+                return 0;
+            }
+
+            if (++this.days_index == this.days.length) {
+                this.days_index = 0;
+                do {
+                    this.increment_year(this.rule.interval);
+                    this.expand_year_days(this.last.year);
+                } while (this.days.length == 0);
+            }
+
+            this._nextByYearDay();
+
+            return 1;
+        },
+
+        _nextByYearDay: function _nextByYearDay() {
+            var doy = this.days[this.days_index];
+            var year = this.last.year;
+            if (doy < 1) {
+                // Time.fromDayOfYear(doy, year) indexes relative to the
+                // start of the given year. That is different from the
+                // semantics of BYYEARDAY where negative indexes are an
+                // offset from the end of the given year.
+                doy += 1;
+                year += 1;
+            }
+            var next = ICAL.Time.fromDayOfYear(doy, year);
+            this.last.day = next.day;
+            this.last.month = next.month;
+        },
+
+        /**
+         * @param dow (eg: '1TU', '-1MO')
+         * @param {ICAL.Time.weekDay=} aWeekStart The week start weekday
+         * @return [pos, numericDow] (eg: [1, 3]) numericDow is relative to aWeekStart
+         */
+        ruleDayOfWeek: function ruleDayOfWeek(dow, aWeekStart) {
+            var matches = dow.match(/([+-]?[0-9])?(MO|TU|WE|TH|FR|SA|SU)/);
+            if (matches) {
+                var pos = parseInt(matches[1] || 0, 10);
+                dow = ICAL.Recur.icalDayToNumericDay(matches[2], aWeekStart);
+                return [pos, dow];
+            } else {
+                return [0, 0];
+            }
+        },
+
+        next_generic: function next_generic(aRuleType, aInterval, aDateAttr,
+            aFollowingAttr, aPreviousIncr) {
+            var has_by_rule = (aRuleType in this.by_data);
+            var this_freq = (this.rule.freq == aInterval);
+            var end_of_data = 0;
+
+            if (aPreviousIncr && this[aPreviousIncr]() == 0) {
+                return end_of_data;
+            }
+
+            if (has_by_rule) {
+                this.by_indices[aRuleType]++;
+                var idx = this.by_indices[aRuleType];
+                var dta = this.by_data[aRuleType];
+
+                if (this.by_indices[aRuleType] == dta.length) {
+                    this.by_indices[aRuleType] = 0;
+                    end_of_data = 1;
+                }
+                this.last[aDateAttr] = dta[this.by_indices[aRuleType]];
+            } else if (this_freq) {
+                this["increment_" + aDateAttr](this.rule.interval);
+            }
+
+            if (has_by_rule && end_of_data && this_freq) {
+                this["increment_" + aFollowingAttr](1);
+            }
+
+            return end_of_data;
+        },
+
+        increment_monthday: function increment_monthday(inc) {
+            for (var i = 0; i < inc; i++) {
+                var daysInMonth = ICAL.Time.daysInMonth(this.last.month, this.last.year);
+                this.last.day++;
+
+                if (this.last.day > daysInMonth) {
+                    this.last.day -= daysInMonth;
+                    this.increment_month();
+                }
+            }
+        },
+
+        increment_month: function increment_month() {
+            this.last.day = 1;
+            if (this.has_by_data("BYMONTH")) {
+                this.by_indices.BYMONTH++;
+
+                if (this.by_indices.BYMONTH == this.by_data.BYMONTH.length) {
+                    this.by_indices.BYMONTH = 0;
+                    this.increment_year(1);
+                }
+
+                this.last.month = this.by_data.BYMONTH[this.by_indices.BYMONTH];
+            } else {
+                if (this.rule.freq == "MONTHLY") {
+                    this.last.month += this.rule.interval;
+                } else {
+                    this.last.month++;
+                }
+
+                this.last.month--;
+                var years = ICAL.helpers.trunc(this.last.month / 12);
+                this.last.month %= 12;
+                this.last.month++;
+
+                if (years != 0) {
+                    this.increment_year(years);
+                }
+            }
+        },
+
+        increment_year: function increment_year(inc) {
+            this.last.year += inc;
+        },
+
+        increment_generic: function increment_generic(inc, aDateAttr,
+            aFactor, aNextIncrement) {
+            this.last[aDateAttr] += inc;
+            var nextunit = ICAL.helpers.trunc(this.last[aDateAttr] / aFactor);
+            this.last[aDateAttr] %= aFactor;
+            if (nextunit != 0) {
+                this["increment_" + aNextIncrement](nextunit);
+            }
+        },
+
+        has_by_data: function has_by_data(aRuleType) {
+            return (aRuleType in this.rule.parts);
+        },
+
+        expand_year_days: function expand_year_days(aYear) {
+            var t = new ICAL.Time();
+            this.days = [];
+
+            // We need our own copy with a few keys set
+            var parts = {};
+            var rules = ["BYDAY", "BYWEEKNO", "BYMONTHDAY", "BYMONTH", "BYYEARDAY"];
+            for (var p in rules) {
+                /* istanbul ignore else */
+                if (rules.hasOwnProperty(p)) {
+                    var part = rules[p];
+                    if (part in this.rule.parts) {
+                        parts[part] = this.rule.parts[part];
+                    }
+                }
+            }
+
+            if ("BYMONTH" in parts && "BYWEEKNO" in parts) {
+                var valid = 1;
+                var validWeeks = {};
+                t.year = aYear;
+                t.isDate = true;
+
+                for (var monthIdx = 0; monthIdx < this.by_data.BYMONTH.length; monthIdx++) {
+                    var month = this.by_data.BYMONTH[monthIdx];
+                    t.month = month;
+                    t.day = 1;
+                    var first_week = t.weekNumber(this.rule.wkst);
+                    t.day = ICAL.Time.daysInMonth(month, aYear);
+                    var last_week = t.weekNumber(this.rule.wkst);
+                    for (monthIdx = first_week; monthIdx < last_week; monthIdx++) {
+                        validWeeks[monthIdx] = 1;
+                    }
+                }
+
+                for (var weekIdx = 0; weekIdx < this.by_data.BYWEEKNO.length && valid; weekIdx++) {
+                    var weekno = this.by_data.BYWEEKNO[weekIdx];
+                    if (weekno < 52) {
+                        valid &= validWeeks[weekIdx];
+                    } else {
+                        valid = 0;
+                    }
+                }
+
+                if (valid) {
+                    delete parts.BYMONTH;
+                } else {
+                    delete parts.BYWEEKNO;
+                }
+            }
+
+            var partCount = Object.keys(parts).length;
+
+            if (partCount == 0) {
+                var t1 = this.dtstart.clone();
+                t1.year = this.last.year;
+                this.days.push(t1.dayOfYear());
+            } else if (partCount == 1 && "BYMONTH" in parts) {
+                for (var monthkey in this.by_data.BYMONTH) {
+                    /* istanbul ignore if */
+                    if (!this.by_data.BYMONTH.hasOwnProperty(monthkey)) {
+                        continue;
+                    }
+                    var t2 = this.dtstart.clone();
+                    t2.year = aYear;
+                    t2.month = this.by_data.BYMONTH[monthkey];
+                    t2.isDate = true;
+                    this.days.push(t2.dayOfYear());
+                }
+            } else if (partCount == 1 && "BYMONTHDAY" in parts) {
+                for (var monthdaykey in this.by_data.BYMONTHDAY) {
+                    /* istanbul ignore if */
+                    if (!this.by_data.BYMONTHDAY.hasOwnProperty(monthdaykey)) {
+                        continue;
+                    }
+                    var t3 = this.dtstart.clone();
+                    var day_ = this.by_data.BYMONTHDAY[monthdaykey];
+                    if (day_ < 0) {
+                        var daysInMonth = ICAL.Time.daysInMonth(t3.month, aYear);
+                        day_ = day_ + daysInMonth + 1;
+                    }
+                    t3.day = day_;
+                    t3.year = aYear;
+                    t3.isDate = true;
+                    this.days.push(t3.dayOfYear());
+                }
+            } else if (partCount == 2 &&
+                "BYMONTHDAY" in parts &&
+                "BYMONTH" in parts) {
+                for (var monthkey in this.by_data.BYMONTH) {
+                    /* istanbul ignore if */
+                    if (!this.by_data.BYMONTH.hasOwnProperty(monthkey)) {
+                        continue;
+                    }
+                    var month_ = this.by_data.BYMONTH[monthkey];
+                    var daysInMonth = ICAL.Time.daysInMonth(month_, aYear);
+                    for (var monthdaykey in this.by_data.BYMONTHDAY) {
+                        /* istanbul ignore if */
+                        if (!this.by_data.BYMONTHDAY.hasOwnProperty(monthdaykey)) {
+                            continue;
+                        }
+                        var day_ = this.by_data.BYMONTHDAY[monthdaykey];
+                        if (day_ < 0) {
+                            day_ = day_ + daysInMonth + 1;
+                        }
+                        t.day = day_;
+                        t.month = month_;
+                        t.year = aYear;
+                        t.isDate = true;
+
+                        this.days.push(t.dayOfYear());
+                    }
+                }
+            } else if (partCount == 1 && "BYWEEKNO" in parts) {
+                // TODO unimplemented in libical
+            } else if (partCount == 2 &&
+                "BYWEEKNO" in parts &&
+                "BYMONTHDAY" in parts) {
+                // TODO unimplemented in libical
+            } else if (partCount == 1 && "BYDAY" in parts) {
+                this.days = this.days.concat(this.expand_by_day(aYear));
+            } else if (partCount == 2 && "BYDAY" in parts && "BYMONTH" in parts) {
+                for (var monthkey in this.by_data.BYMONTH) {
+                    /* istanbul ignore if */
+                    if (!this.by_data.BYMONTH.hasOwnProperty(monthkey)) {
+                        continue;
+                    }
+                    var month = this.by_data.BYMONTH[monthkey];
+                    var daysInMonth = ICAL.Time.daysInMonth(month, aYear);
+
+                    t.year = aYear;
+                    t.month = this.by_data.BYMONTH[monthkey];
+                    t.day = 1;
+                    t.isDate = true;
+
+                    var first_dow = t.dayOfWeek();
+                    var doy_offset = t.dayOfYear() - 1;
+
+                    t.day = daysInMonth;
+                    var last_dow = t.dayOfWeek();
+
+                    if (this.has_by_data("BYSETPOS")) {
+                        var set_pos_counter = 0;
+                        var by_month_day = [];
+                        for (var day = 1; day <= daysInMonth; day++) {
+                            t.day = day;
+                            if (this.is_day_in_byday(t)) {
+                                by_month_day.push(day);
+                            }
+                        }
+
+                        for (var spIndex = 0; spIndex < by_month_day.length; spIndex++) {
+                            if (this.check_set_position(spIndex + 1) ||
+                                this.check_set_position(spIndex - by_month_day.length)) {
+                                this.days.push(doy_offset + by_month_day[spIndex]);
+                            }
+                        }
+                    } else {
+                        for (var daycodedkey in this.by_data.BYDAY) {
+                            /* istanbul ignore if */
+                            if (!this.by_data.BYDAY.hasOwnProperty(daycodedkey)) {
+                                continue;
+                            }
+                            var coded_day = this.by_data.BYDAY[daycodedkey];
+                            var bydayParts = this.ruleDayOfWeek(coded_day);
+                            var pos = bydayParts[0];
+                            var dow = bydayParts[1];
+                            var month_day;
+
+                            var first_matching_day = ((dow + 7 - first_dow) % 7) + 1;
+                            var last_matching_day = daysInMonth - ((last_dow + 7 - dow) % 7);
+
+                            if (pos == 0) {
+                                for (var day = first_matching_day; day <= daysInMonth; day += 7) {
+                                    this.days.push(doy_offset + day);
+                                }
+                            } else if (pos > 0) {
+                                month_day = first_matching_day + (pos - 1) * 7;
+
+                                if (month_day <= daysInMonth) {
+                                    this.days.push(doy_offset + month_day);
+                                }
+                            } else {
+                                month_day = last_matching_day + (pos + 1) * 7;
+
+                                if (month_day > 0) {
+                                    this.days.push(doy_offset + month_day);
+                                }
+                            }
+                        }
+                    }
+                }
+                // Return dates in order of occurrence (1,2,3,...) instead
+                // of by groups of weekdays (1,8,15,...,2,9,16,...).
+                this.days.sort(function (a, b) { return a - b; }); // Comparator function allows to sort numbers.
+            } else if (partCount == 2 && "BYDAY" in parts && "BYMONTHDAY" in parts) {
+                var expandedDays = this.expand_by_day(aYear);
+
+                for (var daykey in expandedDays) {
+                    /* istanbul ignore if */
+                    if (!expandedDays.hasOwnProperty(daykey)) {
+                        continue;
+                    }
+                    var day = expandedDays[daykey];
+                    var tt = ICAL.Time.fromDayOfYear(day, aYear);
+                    if (this.by_data.BYMONTHDAY.indexOf(tt.day) >= 0) {
+                        this.days.push(day);
+                    }
+                }
+            } else if (partCount == 3 &&
+                "BYDAY" in parts &&
+                "BYMONTHDAY" in parts &&
+                "BYMONTH" in parts) {
+                var expandedDays = this.expand_by_day(aYear);
+
+                for (var daykey in expandedDays) {
+                    /* istanbul ignore if */
+                    if (!expandedDays.hasOwnProperty(daykey)) {
+                        continue;
+                    }
+                    var day = expandedDays[daykey];
+                    var tt = ICAL.Time.fromDayOfYear(day, aYear);
+
+                    if (this.by_data.BYMONTH.indexOf(tt.month) >= 0 &&
+                        this.by_data.BYMONTHDAY.indexOf(tt.day) >= 0) {
+                        this.days.push(day);
+                    }
+                }
+            } else if (partCount == 2 && "BYDAY" in parts && "BYWEEKNO" in parts) {
+                var expandedDays = this.expand_by_day(aYear);
+
+                for (var daykey in expandedDays) {
+                    /* istanbul ignore if */
+                    if (!expandedDays.hasOwnProperty(daykey)) {
+                        continue;
+                    }
+                    var day = expandedDays[daykey];
+                    var tt = ICAL.Time.fromDayOfYear(day, aYear);
+                    var weekno = tt.weekNumber(this.rule.wkst);
+
+                    if (this.by_data.BYWEEKNO.indexOf(weekno)) {
+                        this.days.push(day);
+                    }
+                }
+            } else if (partCount == 3 &&
+                "BYDAY" in parts &&
+                "BYWEEKNO" in parts &&
+                "BYMONTHDAY" in parts) {
+                // TODO unimplemted in libical
+            } else if (partCount == 1 && "BYYEARDAY" in parts) {
+                this.days = this.days.concat(this.by_data.BYYEARDAY);
+            } else {
+                this.days = [];
+            }
+            return 0;
+        },
+
+        expand_by_day: function expand_by_day(aYear) {
+
+            var days_list = [];
+            var tmp = this.last.clone();
+
+            tmp.year = aYear;
+            tmp.month = 1;
+            tmp.day = 1;
+            tmp.isDate = true;
+
+            var start_dow = tmp.dayOfWeek();
+
+            tmp.month = 12;
+            tmp.day = 31;
+            tmp.isDate = true;
+
+            var end_dow = tmp.dayOfWeek();
+            var end_year_day = tmp.dayOfYear();
+
+            for (var daykey in this.by_data.BYDAY) {
+                /* istanbul ignore if */
+                if (!this.by_data.BYDAY.hasOwnProperty(daykey)) {
+                    continue;
+                }
+                var day = this.by_data.BYDAY[daykey];
+                var parts = this.ruleDayOfWeek(day);
+                var pos = parts[0];
+                var dow = parts[1];
+
+                if (pos == 0) {
+                    var tmp_start_doy = ((dow + 7 - start_dow) % 7) + 1;
+
+                    for (var doy = tmp_start_doy; doy <= end_year_day; doy += 7) {
+                        days_list.push(doy);
+                    }
+
+                } else if (pos > 0) {
+                    var first;
+                    if (dow >= start_dow) {
+                        first = dow - start_dow + 1;
+                    } else {
+                        first = dow - start_dow + 8;
+                    }
+
+                    days_list.push(first + (pos - 1) * 7);
+                } else {
+                    var last;
+                    pos = -pos;
+
+                    if (dow <= end_dow) {
+                        last = end_year_day - end_dow + dow;
+                    } else {
+                        last = end_year_day - end_dow + dow - 7;
+                    }
+
+                    days_list.push(last - (pos - 1) * 7);
+                }
+            }
+            return days_list;
+        },
+
+        is_day_in_byday: function is_day_in_byday(tt) {
+            for (var daykey in this.by_data.BYDAY) {
+                /* istanbul ignore if */
+                if (!this.by_data.BYDAY.hasOwnProperty(daykey)) {
+                    continue;
+                }
+                var day = this.by_data.BYDAY[daykey];
+                var parts = this.ruleDayOfWeek(day);
+                var pos = parts[0];
+                var dow = parts[1];
+                var this_dow = tt.dayOfWeek();
+
+                if ((pos == 0 && dow == this_dow) ||
+                    (tt.nthWeekDay(dow, pos) == tt.day)) {
+                    return 1;
+                }
+            }
+
+            return 0;
+        },
+
+        /**
+         * Checks if given value is in BYSETPOS.
+         *
+         * @private
+         * @param {Numeric} aPos position to check for.
+         * @return {Boolean} false unless BYSETPOS rules exist
+         *                   and the given value is present in rules.
+         */
+        check_set_position: function check_set_position(aPos) {
+            if (this.has_by_data('BYSETPOS')) {
+                var idx = this.by_data.BYSETPOS.indexOf(aPos);
+                // negative numbers are not false-y
+                return idx !== -1;
+            }
+            return false;
+        },
+
+        sort_byday_rules: function icalrecur_sort_byday_rules(aRules) {
+            for (var i = 0; i < aRules.length; i++) {
+                for (var j = 0; j < i; j++) {
+                    var one = this.ruleDayOfWeek(aRules[j], this.rule.wkst)[1];
+                    var two = this.ruleDayOfWeek(aRules[i], this.rule.wkst)[1];
+
+                    if (one > two) {
+                        var tmp = aRules[i];
+                        aRules[i] = aRules[j];
+                        aRules[j] = tmp;
+                    }
+                }
+            }
+        },
+
+        check_contract_restriction: function check_contract_restriction(aRuleType, v) {
+            var indexMapValue = icalrecur_iterator._indexMap[aRuleType];
+            var ruleMapValue = icalrecur_iterator._expandMap[this.rule.freq][indexMapValue];
+            var pass = false;
+
+            if (aRuleType in this.by_data &&
+                ruleMapValue == icalrecur_iterator.CONTRACT) {
+
+                var ruleType = this.by_data[aRuleType];
+
+                for (var bydatakey in ruleType) {
+                    /* istanbul ignore else */
+                    if (ruleType.hasOwnProperty(bydatakey)) {
+                        if (ruleType[bydatakey] == v) {
+                            pass = true;
+                            break;
+                        }
+                    }
+                }
+            } else {
+                // Not a contracting byrule or has no data, test passes
+                pass = true;
+            }
+            return pass;
+        },
+
+        check_contracting_rules: function check_contracting_rules() {
+            var dow = this.last.dayOfWeek();
+            var weekNo = this.last.weekNumber(this.rule.wkst);
+            var doy = this.last.dayOfYear();
+
+            return (this.check_contract_restriction("BYSECOND", this.last.second) &&
+                this.check_contract_restriction("BYMINUTE", this.last.minute) &&
+                this.check_contract_restriction("BYHOUR", this.last.hour) &&
+                this.check_contract_restriction("BYDAY", ICAL.Recur.numericDayToIcalDay(dow)) &&
+                this.check_contract_restriction("BYWEEKNO", weekNo) &&
+                this.check_contract_restriction("BYMONTHDAY", this.last.day) &&
+                this.check_contract_restriction("BYMONTH", this.last.month) &&
+                this.check_contract_restriction("BYYEARDAY", doy));
+        },
+
+        setup_defaults: function setup_defaults(aRuleType, req, deftime) {
+            var indexMapValue = icalrecur_iterator._indexMap[aRuleType];
+            var ruleMapValue = icalrecur_iterator._expandMap[this.rule.freq][indexMapValue];
+
+            if (ruleMapValue != icalrecur_iterator.CONTRACT) {
+                if (!(aRuleType in this.by_data)) {
+                    this.by_data[aRuleType] = [deftime];
+                }
+                if (this.rule.freq != req) {
+                    return this.by_data[aRuleType][0];
+                }
+            }
+            return deftime;
+        },
+
+        /**
+         * Convert iterator into a serialize-able object.  Will preserve current
+         * iteration sequence to ensure the seamless continuation of the recurrence
+         * rule.
+         * @return {Object}
+         */
+        toJSON: function () {
+            var result = Object.create(null);
+
+            result.initialized = this.initialized;
+            result.rule = this.rule.toJSON();
+            result.dtstart = this.dtstart.toJSON();
+            result.by_data = this.by_data;
+            result.days = this.days;
+            result.last = this.last.toJSON();
+            result.by_indices = this.by_indices;
+            result.occurrence_number = this.occurrence_number;
+
+            return result;
+        }
+    };
+
+    icalrecur_iterator._indexMap = {
+        "BYSECOND": 0,
+        "BYMINUTE": 1,
+        "BYHOUR": 2,
+        "BYDAY": 3,
+        "BYMONTHDAY": 4,
+        "BYYEARDAY": 5,
+        "BYWEEKNO": 6,
+        "BYMONTH": 7,
+        "BYSETPOS": 8
+    };
+
+    icalrecur_iterator._expandMap = {
+        "SECONDLY": [1, 1, 1, 1, 1, 1, 1, 1],
+        "MINUTELY": [2, 1, 1, 1, 1, 1, 1, 1],
+        "HOURLY": [2, 2, 1, 1, 1, 1, 1, 1],
+        "DAILY": [2, 2, 2, 1, 1, 1, 1, 1],
+        "WEEKLY": [2, 2, 2, 2, 3, 3, 1, 1],
+        "MONTHLY": [2, 2, 2, 2, 2, 3, 3, 1],
+        "YEARLY": [2, 2, 2, 2, 2, 2, 2, 2]
+    };
+    icalrecur_iterator.UNKNOWN = 0;
+    icalrecur_iterator.CONTRACT = 1;
+    icalrecur_iterator.EXPAND = 2;
+    icalrecur_iterator.ILLEGAL = 3;
+
+    return icalrecur_iterator;
+
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * This symbol is further described later on
+ * @ignore
+ */
+ICAL.RecurExpansion = (function () {
+    function formatTime(item) {
+        return ICAL.helpers.formatClassType(item, ICAL.Time);
+    }
+
+    function compareTime(a, b) {
+        return a.compare(b);
+    }
+
+    function isRecurringComponent(comp) {
+        return comp.hasProperty('rdate') ||
+            comp.hasProperty('rrule') ||
+            comp.hasProperty('recurrence-id');
+    }
+
+    /**
+     * @classdesc
+     * Primary class for expanding recurring rules.  Can take multiple rrules,
+     * rdates, exdate(s) and iterate (in order) over each next occurrence.
+     *
+     * Once initialized this class can also be serialized saved and continue
+     * iteration from the last point.
+     *
+     * NOTE: it is intended that this class is to be used
+     *       with ICAL.Event which handles recurrence exceptions.
+     *
+     * @example
+     * // assuming event is a parsed ical component
+     * var event;
+     *
+     * var expand = new ICAL.RecurExpansion({
+     *   component: event,
+     *   dtstart: event.getFirstPropertyValue('dtstart')
+     * });
+     *
+     * // remember there are infinite rules
+     * // so it is a good idea to limit the scope
+     * // of the iterations then resume later on.
+     *
+     * // next is always an ICAL.Time or null
+     * var next;
+     *
+     * while (someCondition && (next = expand.next())) {
+     *   // do something with next
+     * }
+     *
+     * // save instance for later
+     * var json = JSON.stringify(expand);
+     *
+     * //...
+     *
+     * // NOTE: if the component's properties have
+     * //       changed you will need to rebuild the
+     * //       class and start over. This only works
+     * //       when the component's recurrence info is the same.
+     * var expand = new ICAL.RecurExpansion(JSON.parse(json));
+     *
+     * @description
+     * The options object can be filled with the specified initial values. It can
+     * also contain additional members, as a result of serializing a previous
+     * expansion state, as shown in the example.
+     *
+     * @class
+     * @alias ICAL.RecurExpansion
+     * @param {Object} options
+     *        Recurrence expansion options
+     * @param {ICAL.Time} options.dtstart
+     *        Start time of the event
+     * @param {ICAL.Component=} options.component
+     *        Component for expansion, required if not resuming.
+     */
+    function RecurExpansion(options) {
+        this.ruleDates = [];
+        this.exDates = [];
+        this.fromData(options);
+    }
+
+    RecurExpansion.prototype = {
+        /**
+         * True when iteration is fully completed.
+         * @type {Boolean}
+         */
+        complete: false,
+
+        /**
+         * Array of rrule iterators.
+         *
+         * @type {ICAL.RecurIterator[]}
+         * @private
+         */
+        ruleIterators: null,
+
+        /**
+         * Array of rdate instances.
+         *
+         * @type {ICAL.Time[]}
+         * @private
+         */
+        ruleDates: null,
+
+        /**
+         * Array of exdate instances.
+         *
+         * @type {ICAL.Time[]}
+         * @private
+         */
+        exDates: null,
+
+        /**
+         * Current position in ruleDates array.
+         * @type {Number}
+         * @private
+         */
+        ruleDateInc: 0,
+
+        /**
+         * Current position in exDates array
+         * @type {Number}
+         * @private
+         */
+        exDateInc: 0,
+
+        /**
+         * Current negative date.
+         *
+         * @type {ICAL.Time}
+         * @private
+         */
+        exDate: null,
+
+        /**
+         * Current additional date.
+         *
+         * @type {ICAL.Time}
+         * @private
+         */
+        ruleDate: null,
+
+        /**
+         * Start date of recurring rules.
+         *
+         * @type {ICAL.Time}
+         */
+        dtstart: null,
+
+        /**
+         * Last expanded time
+         *
+         * @type {ICAL.Time}
+         */
+        last: null,
+
+        /**
+         * Initialize the recurrence expansion from the data object. The options
+         * object may also contain additional members, see the
+         * {@link ICAL.RecurExpansion constructor} for more details.
+         *
+         * @param {Object} options
+         *        Recurrence expansion options
+         * @param {ICAL.Time} options.dtstart
+         *        Start time of the event
+         * @param {ICAL.Component=} options.component
+         *        Component for expansion, required if not resuming.
+         */
+        fromData: function (options) {
+            var start = ICAL.helpers.formatClassType(options.dtstart, ICAL.Time);
+
+            if (!start) {
+                throw new Error('.dtstart (ICAL.Time) must be given');
+            } else {
+                this.dtstart = start;
+            }
+
+            if (options.component) {
+                this._init(options.component);
+            } else {
+                this.last = formatTime(options.last) || start.clone();
+
+                if (!options.ruleIterators) {
+                    throw new Error('.ruleIterators or .component must be given');
+                }
+
+                this.ruleIterators = options.ruleIterators.map(function (item) {
+                    return ICAL.helpers.formatClassType(item, ICAL.RecurIterator);
+                });
+
+                this.ruleDateInc = options.ruleDateInc;
+                this.exDateInc = options.exDateInc;
+
+                if (options.ruleDates) {
+                    this.ruleDates = options.ruleDates.map(formatTime);
+                    this.ruleDate = this.ruleDates[this.ruleDateInc];
+                }
+
+                if (options.exDates) {
+                    this.exDates = options.exDates.map(formatTime);
+                    this.exDate = this.exDates[this.exDateInc];
+                }
+
+                if (typeof (options.complete) !== 'undefined') {
+                    this.complete = options.complete;
+                }
+            }
+        },
+
+        /**
+         * Retrieve the next occurrence in the series.
+         * @return {ICAL.Time}
+         */
+        next: function () {
+            var iter;
+            var ruleOfDay;
+            var next;
+            var compare;
+
+            var maxTries = 500;
+            var currentTry = 0;
+
+            while (true) {
+                if (currentTry++ > maxTries) {
+                    throw new Error(
+                        'max tries have occured, rule may be impossible to forfill.'
+                    );
+                }
+
+                next = this.ruleDate;
+                iter = this._nextRecurrenceIter(this.last);
+
+                // no more matches
+                // because we increment the rule day or rule
+                // _after_ we choose a value this should be
+                // the only spot where we need to worry about the
+                // end of events.
+                if (!next && !iter) {
+                    // there are no more iterators or rdates
+                    this.complete = true;
+                    break;
+                }
+
+                // no next rule day or recurrence rule is first.
+                if (!next || (iter && next.compare(iter.last) > 0)) {
+                    // must be cloned, recur will reuse the time element.
+                    next = iter.last.clone();
+                    // move to next so we can continue
+                    iter.next();
+                }
+
+                // if the ruleDate is still next increment it.
+                if (this.ruleDate === next) {
+                    this._nextRuleDay();
+                }
+
+                this.last = next;
+
+                // check the negative rules
+                if (this.exDate) {
+                    compare = this.exDate.compare(this.last);
+
+                    if (compare < 0) {
+                        this._nextExDay();
+                    }
+
+                    // if the current rule is excluded skip it.
+                    if (compare === 0) {
+                        this._nextExDay();
+                        continue;
+                    }
+                }
+
+                //XXX: The spec states that after we resolve the final
+                //     list of dates we execute exdate this seems somewhat counter
+                //     intuitive to what I have seen most servers do so for now
+                //     I exclude based on the original date not the one that may
+                //     have been modified by the exception.
+                return this.last;
+            }
+        },
+
+        /**
+         * Converts object into a serialize-able format. This format can be passed
+         * back into the expansion to resume iteration.
+         * @return {Object}
+         */
+        toJSON: function () {
+            function toJSON(item) {
+                return item.toJSON();
+            }
+
+            var result = Object.create(null);
+            result.ruleIterators = this.ruleIterators.map(toJSON);
+
+            if (this.ruleDates) {
+                result.ruleDates = this.ruleDates.map(toJSON);
+            }
+
+            if (this.exDates) {
+                result.exDates = this.exDates.map(toJSON);
+            }
+
+            result.ruleDateInc = this.ruleDateInc;
+            result.exDateInc = this.exDateInc;
+            result.last = this.last.toJSON();
+            result.dtstart = this.dtstart.toJSON();
+            result.complete = this.complete;
+
+            return result;
+        },
+
+        /**
+         * Extract all dates from the properties in the given component. The
+         * properties will be filtered by the property name.
+         *
+         * @private
+         * @param {ICAL.Component} component        The component to search in
+         * @param {String} propertyName             The property name to search for
+         * @return {ICAL.Time[]}                    The extracted dates.
+         */
+        _extractDates: function (component, propertyName) {
+            function handleProp(prop) {
+                idx = ICAL.helpers.binsearchInsert(
+                    result,
+                    prop,
+                    compareTime
+                );
+
+                // ordered insert
+                result.splice(idx, 0, prop);
+            }
+
+            var result = [];
+            var props = component.getAllProperties(propertyName);
+            var len = props.length;
+            var i = 0;
+            var prop;
+
+            var idx;
+
+            for (; i < len; i++) {
+                props[i].getValues().forEach(handleProp);
+            }
+
+            return result;
+        },
+
+        /**
+         * Initialize the recurrence expansion.
+         *
+         * @private
+         * @param {ICAL.Component} component    The component to initialize from.
+         */
+        _init: function (component) {
+            this.ruleIterators = [];
+
+            this.last = this.dtstart.clone();
+
+            // to provide api consistency non-recurring
+            // events can also use the iterator though it will
+            // only return a single time.
+            if (!isRecurringComponent(component)) {
+                this.ruleDate = this.last.clone();
+                this.complete = true;
+                return;
+            }
+
+            if (component.hasProperty('rdate')) {
+                this.ruleDates = this._extractDates(component, 'rdate');
+
+                // special hack for cases where first rdate is prior
+                // to the start date. We only check for the first rdate.
+                // This is mostly for google's crazy recurring date logic
+                // (contacts birthdays).
+                if ((this.ruleDates[0]) &&
+                    (this.ruleDates[0].compare(this.dtstart) < 0)) {
+
+                    this.ruleDateInc = 0;
+                    this.last = this.ruleDates[0].clone();
+                } else {
+                    this.ruleDateInc = ICAL.helpers.binsearchInsert(
+                        this.ruleDates,
+                        this.last,
+                        compareTime
+                    );
+                }
+
+                this.ruleDate = this.ruleDates[this.ruleDateInc];
+            }
+
+            if (component.hasProperty('rrule')) {
+                var rules = component.getAllProperties('rrule');
+                var i = 0;
+                var len = rules.length;
+
+                var rule;
+                var iter;
+
+                for (; i < len; i++) {
+                    rule = rules[i].getFirstValue();
+                    iter = rule.iterator(this.dtstart);
+                    this.ruleIterators.push(iter);
+
+                    // increment to the next occurrence so future
+                    // calls to next return times beyond the initial iteration.
+                    // XXX: I find this suspicious might be a bug?
+                    iter.next();
+                }
+            }
+
+            if (component.hasProperty('exdate')) {
+                this.exDates = this._extractDates(component, 'exdate');
+                // if we have a .last day we increment the index to beyond it.
+                this.exDateInc = ICAL.helpers.binsearchInsert(
+                    this.exDates,
+                    this.last,
+                    compareTime
+                );
+
+                this.exDate = this.exDates[this.exDateInc];
+            }
+        },
+
+        /**
+         * Advance to the next exdate
+         * @private
+         */
+        _nextExDay: function () {
+            this.exDate = this.exDates[++this.exDateInc];
+        },
+
+        /**
+         * Advance to the next rule date
+         * @private
+         */
+        _nextRuleDay: function () {
+            this.ruleDate = this.ruleDates[++this.ruleDateInc];
+        },
+
+        /**
+         * Find and return the recurrence rule with the most recent event and
+         * return it.
+         *
+         * @private
+         * @return {?ICAL.RecurIterator}    Found iterator.
+         */
+        _nextRecurrenceIter: function () {
+            var iters = this.ruleIterators;
+
+            if (iters.length === 0) {
+                return null;
+            }
+
+            var len = iters.length;
+            var iter;
+            var iterTime;
+            var iterIdx = 0;
+            var chosenIter;
+
+            // loop through each iterator
+            for (; iterIdx < len; iterIdx++) {
+                iter = iters[iterIdx];
+                iterTime = iter.last;
+
+                // if iteration is complete
+                // then we must exclude it from
+                // the search and remove it.
+                if (iter.completed) {
+                    len--;
+                    if (iterIdx !== 0) {
+                        iterIdx--;
+                    }
+                    iters.splice(iterIdx, 1);
+                    continue;
+                }
+
+                // find the most recent possible choice
+                if (!chosenIter || chosenIter.last.compare(iterTime) > 0) {
+                    // that iterator is saved
+                    chosenIter = iter;
+                }
+            }
+
+            // the chosen iterator is returned but not mutated
+            // this iterator contains the most recent event.
+            return chosenIter;
+        }
+    };
+
+    return RecurExpansion;
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * This symbol is further described later on
+ * @ignore
+ */
+ICAL.Event = (function () {
+
+    /**
+     * @classdesc
+     * ICAL.js is organized into multiple layers. The bottom layer is a raw jCal
+     * object, followed by the component/property layer. The highest level is the
+     * event representation, which this class is part of. See the
+     * {@tutorial layers} guide for more details.
+     *
+     * @class
+     * @alias ICAL.Event
+     * @param {ICAL.Component=} component         The ICAL.Component to base this event on
+     * @param {Object} options                    Options for this event
+     * @param {Boolean} options.strictExceptions
+     *          When true, will verify exceptions are related by their UUID
+     * @param {Array<ICAL.Component|ICAL.Event>} options.exceptions
+     *          Exceptions to this event, either as components or events. If not
+     *            specified exceptions will automatically be set in relation of
+     *            component's parent
+     */
+    function Event(component, options) {
+        if (!(component instanceof ICAL.Component)) {
+            options = component;
+            component = null;
+        }
+
+        if (component) {
+            this.component = component;
+        } else {
+            this.component = new ICAL.Component('vevent');
+        }
+
+        this._rangeExceptionCache = Object.create(null);
+        this.exceptions = Object.create(null);
+        this.rangeExceptions = [];
+
+        if (options && options.strictExceptions) {
+            this.strictExceptions = options.strictExceptions;
+        }
+
+        if (options && options.exceptions) {
+            options.exceptions.forEach(this.relateException, this);
+        } else if (this.component.parent && !this.isRecurrenceException()) {
+            this.component.parent.getAllSubcomponents('vevent').forEach(function (event) {
+                if (event.hasProperty('recurrence-id')) {
+                    this.relateException(event);
+                }
+            }, this);
+        }
+    }
+
+    Event.prototype = {
+
+        THISANDFUTURE: 'THISANDFUTURE',
+
+        /**
+         * List of related event exceptions.
+         *
+         * @type {ICAL.Event[]}
+         */
+        exceptions: null,
+
+        /**
+         * When true, will verify exceptions are related by their UUID.
+         *
+         * @type {Boolean}
+         */
+        strictExceptions: false,
+
+        /**
+         * Relates a given event exception to this object.  If the given component
+         * does not share the UID of this event it cannot be related and will throw
+         * an exception.
+         *
+         * If this component is an exception it cannot have other exceptions
+         * related to it.
+         *
+         * @param {ICAL.Component|ICAL.Event} obj       Component or event
+         */
+        relateException: function (obj) {
+            if (this.isRecurrenceException()) {
+                throw new Error('cannot relate exception to exceptions');
+            }
+
+            if (obj instanceof ICAL.Component) {
+                obj = new ICAL.Event(obj);
+            }
+
+            if (this.strictExceptions && obj.uid !== this.uid) {
+                throw new Error('attempted to relate unrelated exception');
+            }
+
+            var id = obj.recurrenceId.toString();
+
+            // we don't sort or manage exceptions directly
+            // here the recurrence expander handles that.
+            this.exceptions[id] = obj;
+
+            // index RANGE=THISANDFUTURE exceptions so we can
+            // look them up later in getOccurrenceDetails.
+            if (obj.modifiesFuture()) {
+                var item = [
+                    obj.recurrenceId.toUnixTime(), id
+                ];
+
+                // we keep them sorted so we can find the nearest
+                // value later on...
+                var idx = ICAL.helpers.binsearchInsert(
+                    this.rangeExceptions,
+                    item,
+                    compareRangeException
+                );
+
+                this.rangeExceptions.splice(idx, 0, item);
+            }
+        },
+
+        /**
+         * Checks if this record is an exception and has the RANGE=THISANDFUTURE
+         * value.
+         *
+         * @return {Boolean}        True, when exception is within range
+         */
+        modifiesFuture: function () {
+            if (!this.component.hasProperty('recurrence-id')) {
+                return false;
+            }
+
+            var range = this.component.getFirstProperty('recurrence-id').getParameter('range');
+            return range === this.THISANDFUTURE;
+        },
+
+        /**
+         * Finds the range exception nearest to the given date.
+         *
+         * @param {ICAL.Time} time usually an occurrence time of an event
+         * @return {?ICAL.Event} the related event/exception or null
+         */
+        findRangeException: function (time) {
+            if (!this.rangeExceptions.length) {
+                return null;
+            }
+
+            var utc = time.toUnixTime();
+            var idx = ICAL.helpers.binsearchInsert(
+                this.rangeExceptions,
+                [utc],
+                compareRangeException
+            );
+
+            idx -= 1;
+
+            // occurs before
+            if (idx < 0) {
+                return null;
+            }
+
+            var rangeItem = this.rangeExceptions[idx];
+
+            /* istanbul ignore next: sanity check only */
+            if (utc < rangeItem[0]) {
+                return null;
+            }
+
+            return rangeItem[1];
+        },
+
+        /**
+         * This object is returned by {@link ICAL.Event#getOccurrenceDetails getOccurrenceDetails}
+         *
+         * @typedef {Object} occurrenceDetails
+         * @memberof ICAL.Event
+         * @property {ICAL.Time} recurrenceId       The passed in recurrence id
+         * @property {ICAL.Event} item              The occurrence
+         * @property {ICAL.Time} startDate          The start of the occurrence
+         * @property {ICAL.Time} endDate            The end of the occurrence
+         */
+
+        /**
+         * Returns the occurrence details based on its start time.  If the
+         * occurrence has an exception will return the details for that exception.
+         *
+         * NOTE: this method is intend to be used in conjunction
+         *       with the {@link ICAL.Event#iterator iterator} method.
+         *
+         * @param {ICAL.Time} occurrence time occurrence
+         * @return {ICAL.Event.occurrenceDetails} Information about the occurrence
+         */
+        getOccurrenceDetails: function (occurrence) {
+            var id = occurrence.toString();
+            var utcId = occurrence.convertToZone(ICAL.Timezone.utcTimezone).toString();
+            var item;
+            var result = {
+                //XXX: Clone?
+                recurrenceId: occurrence
+            };
+
+            if (id in this.exceptions) {
+                item = result.item = this.exceptions[id];
+                result.startDate = item.startDate;
+                result.endDate = item.endDate;
+                result.item = item;
+            } else if (utcId in this.exceptions) {
+                item = this.exceptions[utcId];
+                result.startDate = item.startDate;
+                result.endDate = item.endDate;
+                result.item = item;
+            } else {
+                // range exceptions (RANGE=THISANDFUTURE) have a
+                // lower priority then direct exceptions but
+                // must be accounted for first. Their item is
+                // always the first exception with the range prop.
+                var rangeExceptionId = this.findRangeException(
+                    occurrence
+                );
+                var end;
+
+                if (rangeExceptionId) {
+                    var exception = this.exceptions[rangeExceptionId];
+
+                    // range exception must modify standard time
+                    // by the difference (if any) in start/end times.
+                    result.item = exception;
+
+                    var startDiff = this._rangeExceptionCache[rangeExceptionId];
+
+                    if (!startDiff) {
+                        var original = exception.recurrenceId.clone();
+                        var newStart = exception.startDate.clone();
+
+                        // zones must be same otherwise subtract may be incorrect.
+                        original.zone = newStart.zone;
+                        startDiff = newStart.subtractDate(original);
+
+                        this._rangeExceptionCache[rangeExceptionId] = startDiff;
+                    }
+
+                    var start = occurrence.clone();
+                    start.zone = exception.startDate.zone;
+                    start.addDuration(startDiff);
+
+                    end = start.clone();
+                    end.addDuration(exception.duration);
+
+                    result.startDate = start;
+                    result.endDate = end;
+                } else {
+                    // no range exception standard expansion
+                    end = occurrence.clone();
+                    end.addDuration(this.duration);
+
+                    result.endDate = end;
+                    result.startDate = occurrence;
+                    result.item = this;
+                }
+            }
+
+            return result;
+        },
+
+        /**
+         * Builds a recur expansion instance for a specific point in time (defaults
+         * to startDate).
+         *
+         * @param {ICAL.Time} startTime     Starting point for expansion
+         * @return {ICAL.RecurExpansion}    Expansion object
+         */
+        iterator: function (startTime) {
+            return new ICAL.RecurExpansion({
+                component: this.component,
+                dtstart: startTime || this.startDate
+            });
+        },
+
+        /**
+         * Checks if the event is recurring
+         *
+         * @return {Boolean}        True, if event is recurring
+         */
+        isRecurring: function () {
+            var comp = this.component;
+            return comp.hasProperty('rrule') || comp.hasProperty('rdate');
+        },
+
+        /**
+         * Checks if the event describes a recurrence exception. See
+         * {@tutorial terminology} for details.
+         *
+         * @return {Boolean}    True, if the event describes a recurrence exception
+         */
+        isRecurrenceException: function () {
+            return this.component.hasProperty('recurrence-id');
+        },
+
+        /**
+         * Returns the types of recurrences this event may have.
+         *
+         * Returned as an object with the following possible keys:
+         *
+         *    - YEARLY
+         *    - MONTHLY
+         *    - WEEKLY
+         *    - DAILY
+         *    - MINUTELY
+         *    - SECONDLY
+         *
+         * @return {Object.<ICAL.Recur.frequencyValues, Boolean>}
+         *          Object of recurrence flags
+         */
+        getRecurrenceTypes: function () {
+            var rules = this.component.getAllProperties('rrule');
+            var i = 0;
+            var len = rules.length;
+            var result = Object.create(null);
+
+            for (; i < len; i++) {
+                var value = rules[i].getFirstValue();
+                result[value.freq] = true;
+            }
+
+            return result;
+        },
+
+        /**
+         * The uid of this event
+         * @type {String}
+         */
+        get uid() {
+            return this._firstProp('uid');
+        },
+
+        set uid(value) {
+            this._setProp('uid', value);
+        },
+
+        /**
+         * The start date
+         * @type {ICAL.Time}
+         */
+        get startDate() {
+            return this._firstProp('dtstart');
+        },
+
+        set startDate(value) {
+            this._setTime('dtstart', value);
+        },
+
+        /**
+         * The end date. This can be the result directly from the property, or the
+         * end date calculated from start date and duration. Setting the property
+         * will remove any duration properties.
+         * @type {ICAL.Time}
+         */
+        get endDate() {
+            var endDate = this._firstProp('dtend');
+            if (!endDate) {
+                var duration = this._firstProp('duration');
+                endDate = this.startDate.clone();
+                if (duration) {
+                    endDate.addDuration(duration);
+                } else if (endDate.isDate) {
+                    endDate.day += 1;
+                }
+            }
+            return endDate;
+        },
+
+        set endDate(value) {
+            if (this.component.hasProperty('duration')) {
+                this.component.removeProperty('duration');
+            }
+            this._setTime('dtend', value);
+        },
+
+        /**
+         * The duration. This can be the result directly from the property, or the
+         * duration calculated from start date and end date. Setting the property
+         * will remove any `dtend` properties.
+         * @type {ICAL.Duration}
+         */
+        get duration() {
+            var duration = this._firstProp('duration');
+            if (!duration) {
+                return this.endDate.subtractDateTz(this.startDate);
+            }
+            return duration;
+        },
+
+        set duration(value) {
+            if (this.component.hasProperty('dtend')) {
+                this.component.removeProperty('dtend');
+            }
+
+            this._setProp('duration', value);
+        },
+
+        /**
+         * The location of the event.
+         * @type {String}
+         */
+        get location() {
+            return this._firstProp('location');
+        },
+
+        set location(value) {
+            return this._setProp('location', value);
+        },
+
+        /**
+         * The attendees in the event
+         * @type {ICAL.Property[]}
+         * @readonly
+         */
+        get attendees() {
+            //XXX: This is way lame we should have a better
+            //     data structure for this later.
+            return this.component.getAllProperties('attendee');
+        },
+
+
+        /**
+         * The event summary
+         * @type {String}
+         */
+        get summary() {
+            return this._firstProp('summary');
+        },
+
+        set summary(value) {
+            this._setProp('summary', value);
+        },
+
+        /**
+         * The event description.
+         * @type {String}
+         */
+        get description() {
+            return this._firstProp('description');
+        },
+
+        set description(value) {
+            this._setProp('description', value);
+        },
+
+        /**
+         * The event color from [rfc7986](https://datatracker.ietf.org/doc/html/rfc7986)
+         * @type {String}
+         */
+        get color() {
+            return this._firstProp('color');
+        },
+
+        set color(value) {
+            this._setProp('color', value);
+        },
+
+        /**
+         * The organizer value as an uri. In most cases this is a mailto: uri, but
+         * it can also be something else, like urn:uuid:...
+         * @type {String}
+         */
+        get organizer() {
+            return this._firstProp('organizer');
+        },
+
+        set organizer(value) {
+            this._setProp('organizer', value);
+        },
+
+        /**
+         * The sequence value for this event. Used for scheduling
+         * see {@tutorial terminology}.
+         * @type {Number}
+         */
+        get sequence() {
+            return this._firstProp('sequence');
+        },
+
+        set sequence(value) {
+            this._setProp('sequence', value);
+        },
+
+        /**
+         * The recurrence id for this event. See {@tutorial terminology} for details.
+         * @type {ICAL.Time}
+         */
+        get recurrenceId() {
+            return this._firstProp('recurrence-id');
+        },
+
+        set recurrenceId(value) {
+            this._setTime('recurrence-id', value);
+        },
+
+        /**
+         * Set/update a time property's value.
+         * This will also update the TZID of the property.
+         *
+         * TODO: this method handles the case where we are switching
+         * from a known timezone to an implied timezone (one without TZID).
+         * This does _not_ handle the case of moving between a known
+         *  (by TimezoneService) timezone to an unknown timezone...
+         *
+         * We will not add/remove/update the VTIMEZONE subcomponents
+         *  leading to invalid ICAL data...
+         * @private
+         * @param {String} propName     The property name
+         * @param {ICAL.Time} time      The time to set
+         */
+        _setTime: function (propName, time) {
+            var prop = this.component.getFirstProperty(propName);
+
+            if (!prop) {
+                prop = new ICAL.Property(propName);
+                this.component.addProperty(prop);
+            }
+
+            // utc and local don't get a tzid
+            if (
+                time.zone === ICAL.Timezone.localTimezone ||
+                time.zone === ICAL.Timezone.utcTimezone
+            ) {
+                // remove the tzid
+                prop.removeParameter('tzid');
+            } else {
+                prop.setParameter('tzid', time.zone.tzid);
+            }
+
+            prop.setValue(time);
+        },
+
+        _setProp: function (name, value) {
+            this.component.updatePropertyWithValue(name, value);
+        },
+
+        _firstProp: function (name) {
+            return this.component.getFirstPropertyValue(name);
+        },
+
+        /**
+         * The string representation of this event.
+         * @return {String}
+         */
+        toString: function () {
+            return this.component.toString();
+        }
+
+    };
+
+    function compareRangeException(a, b) {
+        if (a[0] > b[0]) return 1;
+        if (b[0] > a[0]) return -1;
+        return 0;
+    }
+
+    return Event;
+}());
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * Portions Copyright (C) Philipp Kewisch, 2011-2015 */
+
+
+/**
+ * This symbol is further described later on
+ * @ignore
+ */
+ICAL.ComponentParser = (function () {
+    /**
+     * @classdesc
+     * The ComponentParser is used to process a String or jCal Object,
+     * firing callbacks for various found components, as well as completion.
+     *
+     * @example
+     * var options = {
+     *   // when false no events will be emitted for type
+     *   parseEvent: true,
+     *   parseTimezone: true
+     * };
+     *
+     * var parser = new ICAL.ComponentParser(options);
+     *
+     * parser.onevent(eventComponent) {
+     *   //...
+     * }
+     *
+     * // ontimezone, etc...
+     *
+     * parser.oncomplete = function() {
+     *
+     * };
+     *
+     * parser.process(stringOrComponent);
+     *
+     * @class
+     * @alias ICAL.ComponentParser
+     * @param {Object=} options        Component parser options
+     * @param {Boolean} options.parseEvent        Whether events should be parsed
+     * @param {Boolean} options.parseTimezeone    Whether timezones should be parsed
+     */
+    function ComponentParser(options) {
+        if (typeof (options) === 'undefined') {
+            options = {};
+        }
+
+        var key;
+        for (key in options) {
+            /* istanbul ignore else */
+            if (options.hasOwnProperty(key)) {
+                this[key] = options[key];
+            }
+        }
+    }
+
+    ComponentParser.prototype = {
+
+        /**
+         * When true, parse events
+         *
+         * @type {Boolean}
+         */
+        parseEvent: true,
+
+        /**
+         * When true, parse timezones
+         *
+         * @type {Boolean}
+         */
+        parseTimezone: true,
+
+
+        /* SAX like events here for reference */
+
+        /**
+         * Fired when parsing is complete
+         * @callback
+         */
+        oncomplete: /* istanbul ignore next */ function () { },
+
+        /**
+         * Fired if an error occurs during parsing.
+         *
+         * @callback
+         * @param {Error} err details of error
+         */
+        onerror: /* istanbul ignore next */ function (err) { },
+
+        /**
+         * Fired when a top level component (VTIMEZONE) is found
+         *
+         * @callback
+         * @param {ICAL.Timezone} component     Timezone object
+         */
+        ontimezone: /* istanbul ignore next */ function (component) { },
+
+        /**
+         * Fired when a top level component (VEVENT) is found.
+         *
+         * @callback
+         * @param {ICAL.Event} component    Top level component
+         */
+        onevent: /* istanbul ignore next */ function (component) { },
+
+        /**
+         * Process a string or parse ical object.  This function itself will return
+         * nothing but will start the parsing process.
+         *
+         * Events must be registered prior to calling this method.
+         *
+         * @param {ICAL.Component|String|Object} ical      The component to process,
+         *        either in its final form, as a jCal Object, or string representation
+         */
+        process: function (ical) {
+            //TODO: this is sync now in the future we will have a incremental parser.
+            if (typeof (ical) === 'string') {
+                ical = ICAL.parse(ical);
+            }
+
+            if (!(ical instanceof ICAL.Component)) {
+                ical = new ICAL.Component(ical);
+            }
+
+            var components = ical.getAllSubcomponents();
+            var i = 0;
+            var len = components.length;
+            var component;
+
+            for (; i < len; i++) {
+                component = components[i];
+
+                switch (component.name) {
+                    case 'vtimezone':
+                        if (this.parseTimezone) {
+                            var tzid = component.getFirstPropertyValue('tzid');
+                            if (tzid) {
+                                this.ontimezone(new ICAL.Timezone({
+                                    tzid: tzid,
+                                    component: component
+                                }));
+                            }
+                        }
+                        break;
+                    case 'vevent':
+                        if (this.parseEvent) {
+                            this.onevent(new ICAL.Event(component));
+                        }
+                        break;
+                    default:
+                        continue;
+                }
+            }
+
+            //XXX: ideally we should do a "nextTick" here
+            //     so in all cases this is actually async.
+            this.oncomplete();
+        }
+    };
+
+    return ComponentParser;
+}());
diff --git a/modules/index.js b/modules/index.js
new file mode 100644
index 0000000..0389f1b
--- /dev/null
+++ b/modules/index.js
@@ -0,0 +1,21 @@
+// Placeholder code from Anime Detour testing
+
+import { ICAL } from '/assets/modules/ical_moz.js';
+
+async function getWebDAV() {
+  const calrequest = await fetch("https://next.abtmtr.link/remote.php/dav/public-calendars/83tEFQ3myCro3WBL?export");
+  const calendar = await calrequest.text();
+  const jcal = ICAL.parse(calendar);
+  const comp = new ICAL.Component(jcal);
+  const events = comp.getAllSubcomponents("vevent").map(x => new ICAL.Event(x));
+  const elt = events.map(x => ({
+    summary: x.summary,
+    startDate: x.startDate.toJSDate(),
+    endDate: x.endDate.toJSDate(),
+    description: x.description,
+    location: x.location
+  }));
+  console.log(events, elt);
+}
+
+getWebDAV();
\ No newline at end of file
diff --git a/nodemon.json b/nodemon.json
new file mode 100644
index 0000000..714fdd5
--- /dev/null
+++ b/nodemon.json
@@ -0,0 +1,3 @@
+{
+  "ignore": [".gitignore", ".git/**"]
+}
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..9bbe217
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,1040 @@
+{
+  "name": "eventmapper",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "eventmapper",
+      "version": "1.0.0",
+      "license": "MIT",
+      "dependencies": {
+        "express": "^4.19.2"
+      },
+      "devDependencies": {
+        "nodemon": "^3.1.1"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg=="
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.2",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.2.tgz",
+      "integrity": "sha512-ml9pReCu3M61kGlqoTm2umSXTlRTuGTx0bfYj+uIUKKYycG5NtSbeetV3faSU6R7ajOPw0g/J1PvK4qNy7s5bA==",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "on-finished": "2.4.1",
+        "qs": "6.11.0",
+        "raw-body": "2.5.2",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz",
+      "integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==",
+      "dependencies": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "set-function-length": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.6.0.tgz",
+      "integrity": "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ=="
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "dependencies": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="
+    },
+    "node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz",
+      "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==",
+      "dependencies": {
+        "get-intrinsic": "^1.2.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.19.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.19.2.tgz",
+      "integrity": "sha512-5T6nhjsT+EOMzuck8JjBHARTHfMht0POzlA60WV2pMD3gyXw2LZnZ+ueGdNxG+0calOJcWKbpFcuzLZ91YWq9Q==",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.20.2",
+        "content-disposition": "0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "0.6.0",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.2.0",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "1.0.1",
+        "methods": "~1.1.2",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.7",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.11.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "0.18.0",
+        "serve-static": "1.15.0",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
+      "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "2.0.1",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz",
+      "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "has-proto": "^1.0.1",
+        "has-symbols": "^1.0.3",
+        "hasown": "^2.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
+      "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
+      "dependencies": {
+        "get-intrinsic": "^1.1.3"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "dev": true,
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/has-property-descriptors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "dependencies": {
+        "es-define-property": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-proto": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz",
+      "integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
+      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ignore-by-default": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz",
+      "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==",
+      "dev": true
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz",
+      "integrity": "sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w=="
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/nodemon": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.1.tgz",
+      "integrity": "sha512-k43xGaDtaDIcufn0Fc6fTtsdKSkV/hQzoQFigNH//GaKta28yoKVYXCnV+KXRqfT/YzsFaQU9VdeEG+HEyxr6A==",
+      "dev": true,
+      "dependencies": {
+        "chokidar": "^3.5.2",
+        "debug": "^4",
+        "ignore-by-default": "^1.0.1",
+        "minimatch": "^3.1.2",
+        "pstree.remy": "^1.1.8",
+        "semver": "^7.5.3",
+        "simple-update-notifier": "^2.0.0",
+        "supports-color": "^5.5.0",
+        "touch": "^3.1.0",
+        "undefsafe": "^2.0.5"
+      },
+      "bin": {
+        "nodemon": "bin/nodemon.js"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nodemon"
+      }
+    },
+    "node_modules/nodemon/node_modules/debug": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
+      "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
+      "dev": true,
+      "dependencies": {
+        "ms": "2.1.2"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/nodemon/node_modules/ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+      "dev": true
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.1",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.1.tgz",
+      "integrity": "sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.7",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
+      "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ=="
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/pstree.remy": {
+      "version": "1.1.8",
+      "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",
+      "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==",
+      "dev": true
+    },
+    "node_modules/qs": {
+      "version": "6.11.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz",
+      "integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==",
+      "dependencies": {
+        "side-channel": "^1.0.4"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
+      "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
+    },
+    "node_modules/semver": {
+      "version": "7.6.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.2.tgz",
+      "integrity": "sha512-FNAIBWCx9qcRhoHcgcJ0gvU7SN1lYU2ZXuSfl04bSC5OpvDHFyJCjdNHomPXxjQlCBU67YW64PzY7/VIEH7F2w==",
+      "dev": true,
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/send": {
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz",
+      "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+    },
+    "node_modules/serve-static": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz",
+      "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==",
+      "dependencies": {
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.18.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/set-function-length": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
+      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
+      "dependencies": {
+        "define-data-property": "^1.1.4",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "gopd": "^1.0.1",
+        "has-property-descriptors": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="
+    },
+    "node_modules/side-channel": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz",
+      "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==",
+      "dependencies": {
+        "call-bind": "^1.0.7",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.4",
+        "object-inspect": "^1.13.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/simple-update-notifier": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+      "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+      "dev": true,
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/touch": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.1.tgz",
+      "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==",
+      "dev": true,
+      "bin": {
+        "nodetouch": "bin/nodetouch.js"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/undefsafe": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz",
+      "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==",
+      "dev": true
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..75260dd
--- /dev/null
+++ b/package.json
@@ -0,0 +1,17 @@
+{
+  "name": "eventmapper",
+  "version": "1.0.0",
+  "description": "TODO: Readme",
+  "main": "index.js",
+  "scripts": {
+    "dev": "nodemon ./scripts/server.js"
+  },
+  "author": "MeowcaTheoRange",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.19.2"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.1"
+  }
+}
diff --git a/pages/index.html b/pages/index.html
new file mode 100644
index 0000000..ac9f515
--- /dev/null
+++ b/pages/index.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <title></title>
+    <meta name="description" content="" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link
+      rel="stylesheet"
+      href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css"
+      integrity="sha256-p4NxAoJBhIIN+hmNHrzRCf9tD/miZyoHS5obTRR9BMY="
+      crossorigin=""
+    />
+  </head>
+  <body>
+    <div id="leaflet-map"></div>
+
+    <script
+      src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"
+      integrity="sha256-20nQCchB9co0qIjJZRGuk2/Z9VM+kNiyxNV1lvTlZBo="
+      crossorigin=""
+    ></script>
+    <script src="" type="module"></script>
+  </body>
+</html>
diff --git a/scripts/server.js b/scripts/server.js
new file mode 100644
index 0000000..e69de29