diff --git a/Calendar.js b/Calendar.js
new file mode 100644
index 0000000..2679c21
--- /dev/null
+++ b/Calendar.js
@@ -0,0 +1,478 @@
+String.prototype.hashCode = function() {
+  var hash = 0, i, chr
+  if (this.length === 0) return hash
+  for (i = 0; i < this.length; i++) {
+    chr   = this.charCodeAt(i)
+    hash  = ((hash << 5) - hash) + chr
+    hash |= 0; // Convert to 32bit integer
+  }
+  return String((hash >>> 0))
+}
+
+var iCal = require('../vendor/ical.js')
+//var iCal = require('ical')
+//var iCal = require('./ical.js')
+var moment = require('moment')
+var Pubsub = require('./Pubsub.js')
+
+function Calendar (calConfig, sender=null, autostart=0) {
+  this.type = 'static'
+  this.autostart = autostart
+  this.sender = sender
+  this.config = calConfig
+  this.name = this.config.name
+  this.timestamp = moment().format('x')
+  this.timer = null
+  //this.replace = null
+
+  this.status = {
+    state : 'not fetched yet',
+    lastFetchedTime : null,
+    lastFetchedEvents : null,
+    lastFetchedOldEvents : null,
+    lastServedEvents : null,
+    error: null
+  }
+/*
+  if(typeof this.config.replace === 'undefined') {
+    this.replace = []
+  } else {
+    this.replace = this.config.replace
+  }
+*/
+  this.httpUrl = this.config.url.replace("webcal://", "http://")
+  this.opts = null
+
+  var nodeVersion = Number(process.version.match(/^v(\d+\.\d+)/)[1])
+  this.opts = {
+    "headers" : {
+      "User-Agent":
+        "Mozilla/5.0 (Node.js "
+        + nodeVersion + ") MagicMirror/"
+        + global.version
+        + " (https://github.com/MichMich/MagicMirror/)"
+    }
+  }
+  if (this.config.auth) {
+    if(this.config.auth.method === "bearer"){
+      this.opts.auth = {
+        bearer: this.config.auth.pass
+      }
+    } else {
+      this.opts.auth = {
+        user: this.config.auth.user,
+        pass: this.config.auth.pass
+      }
+      if(this.config.auth.method === "digest"){
+        this.opts.auth.sendImmediately = 0
+      }else{
+        this.opts.auth.sendImmediately = 1
+      }
+    }
+  }
+
+  //this.uid = (this.sender + this.name + this.httpUrl).hashCode()
+  this.uid = this.httpUrl
+  this.events = []
+  //this.events = new CalendarEvents(this.config.maxEntries, this.uid)
+
+  //this.fetcher = new Fetcher(this)
+  if (autostart) {
+    this.fetch()
+    this.activate()
+  }
+}
+Calendar.prototype.fetch = function() {
+  console.log("[CALEXT]",this.httpUrl, " >> Fetch starts.")
+  var self = this
+  self.status.state = 'fetching'
+
+  iCal.fromURL(this.httpUrl, this.opts, function(err, data) {
+    if (err) {
+      console.log('Error in iCal Parsing.')
+      console.log(self.opts)
+      console.log(err)
+      self.nonewEvents([])
+      return
+    }
+    var events = []
+    var oldEvents = []
+    var eventDate = function(event, time) {
+      return (event[time].length === 8)
+        ? moment(event[time], "YYYYMMDD").startOf('day')
+        : moment(event[time])
+    }
+    var now = moment()
+    var today = moment().startOf("day")
+    var past = moment().startOf('month').startOf('week').startOf('day')
+    var future = moment().add(self.config.maxDays - 1, "days").endOf("day")
+
+    // parsed item iteration
+    for (var e in data) {
+      var event = data[e]
+      //var now = moment()
+      //var today = moment().startOf('day')
+      var title = "Unknown Event"
+      var description = ""
+      var location = null
+      var geo = null
+      var uid = null
+      var isFulldayEvent = 0
+      var startDate = null
+      var endDate = null
+      // start of VEVENT
+      if (event.type === 'VEVENT') {
+
+      	if (event.summary) {
+          title
+            = (typeof event.summary.val !== "undefined")
+              ? event.summary.val
+              : event.summary
+        } else if (event.description) {
+          title = event.description
+        }
+
+      	location = event.location || null
+        geo = event.geo || null
+        description = event.description || null
+
+        if (!event.uid) {
+          uid
+            = (title + moment(event.start).format('x')).hashCode()
+            + '@' + this.uid
+        } else {
+            uid = event.uid
+        }
+
+      	// Get the start and end dates from the event.  If the end date is undefined,
+		// assume the event starts and ends on the same day.
+        startDate = eventDate(event, "start");
+        if (typeof event.end !== "undefined") {
+        	endDate = eventDate(event, "end");
+        } else {
+      		endDate = startDate;
+        }
+
+      	// calculate the duration of the event for use with recurring events.
+        var duration = parseInt(endDate.format("x")) - parseInt(startDate.format("x"));
+
+      	// If the start date has a date but no time, assume it's intended to start 
+		// at the start of the day.
+        if (event.start.length === 8) {
+        	startDate = startDate.startOf("day");
+        }
+
+        //RRULE exists? It means recurred.
+        if (typeof event.rrule !== 'undefined') {
+
+          var addedEvents = 0;
+
+          // For recurring events, get the set of start dates that fall within the range
+          // of dates we're looking for.
+          var dates = event.rrule.between(
+            past.toDate(),
+            future.toDate(),
+            true,
+            function(date, i) {return true;}
+          )
+
+          // The "dates" array contains the set of dates within our desired date range range that are valid
+          // for the recurrence rule.  *However*, it's possible for us to have a specific recurrence that
+          // had its date changed from outside the range to inside the range.  For the time being,
+          // we'll handle this by adding *all* recurrence entries into the set of dates that we check,
+          // because the logic below will filter out any recurrences that don't actually belong within
+          // our display range.
+          // TODO: Find a better way to handle this.
+          if (event.recurrences != undefined)
+          {
+          	var pastMoment = moment(past);
+          	var futureMoment = moment(future);
+							
+          	for (var r in event.recurrences)
+          	{
+          		// Only add dates that weren't already in the range we added from the rrule so that 
+          		// we don't double-add those events.
+          		if (moment(new Date(r)).isBetween(pastMoment, futureMoment) != true)
+          		{
+          			dates.push(new Date(r));
+          		}
+          	}
+          }
+
+		  // Loop through the set of date entries to see which recurrences should be added to our event list.
+          for(var i in dates) {
+
+            var date = dates[i];
+            var curEvent = event;
+            var showRecurrence = true;
+
+            startDate = moment(date);
+
+          	// For each date that we're checking, it's possible that there is a recurrence override for that one day.
+            if ((curEvent.recurrences != undefined) && (curEvent.recurrences[date.toISOString()] != undefined))
+            {
+            	// We found an override, so for this recurrence, use a potentially different title, start date, and duration.
+            	curEvent = curEvent.recurrences[date.toISOString()];
+            	startDate = moment(curEvent.start);
+            	duration = parseInt(moment(curEvent.end).format("x")) - parseInt(startDate.format("x"));
+			}
+            // If there's no recurrence override, check for an exception date.  Exception dates represent exceptions to the rule.
+            else if ((curEvent.exdate != undefined) && (curEvent.exdate[date.toISOString()] != undefined))
+            {
+            	// This date is an exception date, which means we should skip it in the recurrence pattern.
+            	showRecurrence = false;
+            }
+
+            endDate = moment(parseInt(startDate.format("x")) + duration, 'x');
+            var recurrenceTitle = getTitleFromEvent(curEvent);
+
+          	// If this recurrence ends before the start of the date range, or starts after the end of the date range, don't add 
+			// it to the event list.
+            if (endDate.isBefore(past) || startDate.isAfter(future)) {
+            	showRecurrence = false;
+            }
+
+            if ((showRecurrence === true) && (addedEvents < self.config.maxEntries)) {
+
+            	addedEvents++;
+
+            	var et = {
+            		'uid': uid + ':' + i,
+            		'name': self.name,
+            		'profiles': self.config.profiles,
+            		'views': self.config.views,
+            		'symbol': self.config.symbol,
+            		'styleName': self.config.styleName,
+            		'replaceTitle': self.config.replaceTitle,
+            		'classPattern' : self.config.classPattern,
+            		'classPatternWhere' : self.config.classPatternWhere,
+            		'ellipsis': self.config.ellipsis,
+            		'oneLineEvent': self.config.oneLineEvent,
+            		'title': recurrenceTitle,
+            		'description': description,
+            		'location': location,
+            		'geo': geo,
+            		'startDate': startDate.format('x'),
+            		'endDate': endDate.format("x"),
+            		'fullDayEvent': isFullDayEvent(curEvent),
+            		'firstOccurrence': moment(event.start).format('x'),
+            		'recurred': 1,
+            		'occurrence': i
+            	}
+
+            	if (startDate.isBefore(now) && endDate.isBefore(now)) {
+            		oldEvents.push(et)
+            	} else {
+            		events.push(et)
+            	}
+            }
+
+          } //iteration of rrule
+        //recurred event fetch over
+        } else {
+          //single
+          startDate = moment(event.start)
+          if (typeof event.end !== 'undefined') {
+            //event.end exists.
+            endDate = moment(event.end)
+          } else {
+            //event.end doesn't exist mean FulldayEvent.
+            if (typeof event.duration !== 'undefined') {
+              //event.end doesn't exist, but duration exists.
+              endDate = moment(startDate).add(moment.duration(event.duration))
+            } else {
+              //event.end and duration don't exist.
+              endDate = moment(startDate)
+              isFulldayEvent = 1
+            }
+          }
+          if(
+            (startDate.format('HHmmss') == '000000')
+            && (endDate.format('HHmmss') == '000000')
+          ) {
+            isFulldayEvent = 1
+          }
+
+          if (startDate.isBefore(past) || endDate.isAfter(future)) {
+            continue
+          }
+
+          var et = {
+            'uid': uid,
+            'name': self.name,
+            'profiles': self.config.profiles,
+            'views': self.config.views,
+            'styleName': self.config.styleName,
+            'replaceTitle': self.config.replaceTitle,
+            'classPattern' : self.config.classPattern,
+            'classPatternWhere' : self.config.classPatternWhere,
+            'symbol': self.config.symbol,
+            'ellipsis': self.config.ellipsis,
+            'oneLineEvent': self.config.oneLineEvent,
+            'title': title,
+            'description': description,
+            'location': location,
+            'geo': geo,
+            'startDate': startDate.format('x'),
+            'endDate': endDate.format("x"),
+            'fullDayEvent': isFulldayEvent,
+            'firstOccurrence': null,
+            'recurred': 0,
+            'occurrence': 0
+          }
+          if (startDate.isBefore(now)) {
+            oldEvents.push(et)
+          } else {
+            events.push(et)
+          }
+          // finish check fulldayevent and parsing startDate, endDate
+        }
+        // single event fetch over
+      }
+      // end of 'VEVENT'
+      else {
+        //console.log(e)
+        //do nothing;
+      }
+      //end of events not 'VEVENT'
+    }
+    // end of iteration each data
+
+    events.sort(function(a, b) {
+      return a.startDate - b.startDate
+    })
+    self.status.state = 'fetched'
+    self.status.lastFetchedTime = moment().format('YY-MM-DD HH:mm:ss')
+    self.status.lastFetchedEvents = events.length
+    self.status.lastFetchedOldEvents = oldEvents.length
+    events = events.slice(0, self.config.maxEntries)
+    var finalEvents = events.concat(oldEvents)
+    finalEvents.sort(function(a, b) {
+      return a.startDate - b.startDate
+    })
+    self.status.lastServedEvents = finalEvents.length
+    if(events !== 'undefined' && finalEvents.length > 0) {
+      if(self.isEventsChanged(finalEvents)) {
+        self.renewEvents(finalEvents)
+        self.status.state = 'renewed'
+      } else {
+        self.nonewEvents(finalEvents)
+        self.status.state = 'fetched but no change'
+      }
+    }
+
+    console.log("[CALEXT]",self.httpUrl, " >> ")
+    console.log(self.status)
+  })
+  // iCal end.
+}
+
+/* getTitleFromEvent(event)
+* Gets the title from the event.
+*
+* argument event object - The event object to check.
+*
+* return string - The title of the event, or "Event" if no title is found.
+*/
+var getTitleFromEvent = function (event) {
+	var title = "Event";
+	if (event.summary) {
+		title = (typeof event.summary.val !== "undefined") ? event.summary.val : event.summary;
+	} else if (event.description) {
+		title = event.description;
+	}
+
+	return title;
+};
+
+/* isFullDayEvent(event)
+* Checks if an event is a fullday event.
+*
+* argument event obejct - The event object to check.
+*
+* return bool - The event is a fullday event.
+*/
+var isFullDayEvent = function(event) {
+	if (event.start.length === 8) {
+		return true;
+	}
+ 
+	var start = event.start || 0;
+	var startDate = new Date(start);
+	var end = event.end || 0;
+ 
+	if (end - start === 24 * 60 * 60 * 1000 && startDate.getHours() === 0 && startDate.getMinutes() === 0) {
+		// Is 24 hours, and starts on the middle of the night.
+		return true;
+	}
+ 
+	return false;
+};
+
+Calendar.prototype.isEventsChanged = function(eArray) {
+  if (typeof eArray == 'undefined') return 0
+  if (eArray.length <= 0) return 0
+  if (this.events.length == 0) return 1
+  if (this.events.length !== eArray.length) return 1
+
+  var cIndex = this.events.map(function(e) {return e.uid}).sort()
+  var eIndex = eArray.map(function(e) {return e.uid}).sort()
+
+  if (cIndex.length !== eIndex.length) return 1
+
+  for (var i = 0; i < cIndex.length; ++i) {
+    if (cIndex[i] !== eIndex[i]) return 1
+  }
+
+  for (var i = 0; i < this.events.length; i++) {
+    var ce = this.events[i];
+    var eA = eArray.filter(function(e) {return (e.uid == ce.uid) ? 1 : 0})
+
+    if (eA.length > 0) var ee = eA[0]
+    if (ee.title !== ce.title) return 1
+    if (ee.endDate !== ce.endDate) return 1
+    if (ee.location !== ce.location) return 1
+    if (ee.startDate !== ce.startDate) return 1
+    if (ee.description !== ce.description) return 1
+  }
+  return 0
+}
+Calendar.prototype.renewEvents = function(eArray) {
+  this.events = eArray
+  this.timestamp = moment().format('x')
+  Pubsub.emit('CALENDAR_MODIFIED')
+    //console.log(this.events)
+}
+
+Calendar.prototype.nonewEvents = function(eArray) {
+  Pubsub.emit('CALENDAR_FETCHED_BUT_NOT_MODIFIED')
+}
+
+Calendar.prototype.getAllEvents = function() {
+  return this.events
+}
+
+Calendar.prototype.suicide = function () {
+  this.deactivate()
+  this.config = null
+  this.events = null
+}
+
+Calendar.prototype.activate = function () {
+  clearInterval(this.timer)
+  var self = this
+  this.timer = setInterval(function() {
+    self.fetch()
+  }, this.config.interval)
+}
+
+Calendar.prototype.deactivate = function () {
+    clearInterval(this.timer)
+    this.timer = null
+}
+
+Calendar.prototype.errorCallback = function() {
+
+}
+
+module.exports = Calendar
diff --git a/ical.js b/ical.js
new file mode 100644
index 0000000..92b9672
--- /dev/null
+++ b/ical.js
@@ -0,0 +1,431 @@
+(function(name, definition) {
+
+/****************
+ *  A tolerant, minimal icalendar parser
+ *  (http://tools.ietf.org/html/rfc5545)
+ *
+ *  <peterbraden@peterbraden.co.uk>
+ * **************/
+
+  if (typeof module !== 'undefined') {
+    module.exports = definition();
+  } else if (typeof define === 'function' && typeof define.amd === 'object'){
+    define(definition);
+  } else {
+    this[name] = definition();
+  }
+
+}('ical', function(){
+
+   // Unescape Text re RFC 4.3.11
+  var text = function(t){
+    t = t || "";
+    return (t
+      .replace(/\\\,/g, ',')
+      .replace(/\\\;/g, ';')
+      .replace(/\\[nN]/g, '\n')
+      .replace(/\\\\/g, '\\')
+    )
+  }
+
+  var parseParams = function(p){
+    var out = {}
+    for (var i = 0; i<p.length; i++){
+      if (p[i].indexOf('=') > -1){
+        var segs = p[i].split('=');
+        
+        out[segs[0]] = parseValue(segs.slice(1).join('='));
+        
+      }
+    }
+    return out || sp
+  }
+
+  var parseValue = function(val){
+    if ('TRUE' === val)
+      return true;
+    
+    if ('FALSE' === val)
+      return false;
+
+    var number = Number(val);
+    if (!isNaN(number))
+      return number;
+
+    return val;
+  }
+
+  var storeValParam = function (name) {
+      return function (val, curr) {
+          var current = curr[name];
+          if (Array.isArray(current)) {
+              current.push(val);
+              return curr;
+          }
+
+          if (current != null) {
+              curr[name] = [current, val];
+              return curr;
+          }
+
+          curr[name] = val;
+          return curr
+      }
+  }
+
+  var storeParam = function (name) {
+      return function (val, params, curr) {
+          var data;
+          if (params && params.length && !(params.length == 1 && params[0] === 'CHARSET=utf-8')) {
+              data = { params: parseParams(params), val: text(val) }
+          }
+          else
+              data = text(val)
+
+          return storeValParam(name)(data, curr);
+      }
+  }
+
+  var addTZ = function (dt, params) {
+    var p = parseParams(params);
+
+    if (params && p){
+      dt.tz = p.TZID
+    }
+
+    return dt
+  }
+
+  var dateParam = function(name){
+      return function (val, params, curr) {
+
+      var newDate = text(val);
+
+
+      if (params && params[0] === "VALUE=DATE") {
+        // Just Date
+
+        var comps = /^(\d{4})(\d{2})(\d{2})$/.exec(val);
+        if (comps !== null) {
+          // No TZ info - assume same timezone as this computer
+          newDate = new Date(
+            comps[1],
+            parseInt(comps[2], 10)-1,
+            comps[3]
+          );
+
+          newDate = addTZ(newDate, params);
+
+          // Store as string - worst case scenario
+          return storeValParam(name)(newDate, curr)
+        }
+      }
+
+
+      //typical RFC date-time format
+      var comps = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(Z)?$/.exec(val);
+      if (comps !== null) {
+        if (comps[7] == 'Z'){ // GMT
+          newDate = new Date(Date.UTC(
+            parseInt(comps[1], 10),
+            parseInt(comps[2], 10)-1,
+            parseInt(comps[3], 10),
+            parseInt(comps[4], 10),
+            parseInt(comps[5], 10),
+            parseInt(comps[6], 10 )
+          ));
+          // TODO add tz
+        } else {
+          newDate = new Date(
+            parseInt(comps[1], 10),
+            parseInt(comps[2], 10)-1,
+            parseInt(comps[3], 10),
+            parseInt(comps[4], 10),
+            parseInt(comps[5], 10),
+            parseInt(comps[6], 10)
+          );
+        }
+
+        newDate = addTZ(newDate, params);
+    }
+
+
+          // Store as string - worst case scenario
+      return storeValParam(name)(newDate, curr)
+      }
+  }
+
+  var exdateParam = function(name){
+    return function(val, params, curr){
+      var date = dateParam(name)(val, params, curr);
+      if (date.exdates === undefined) {
+        date.exdates = [];
+      }
+      date.exdates.push(date.exdate);
+      return date;
+    }
+  }
+
+  var geoParam = function(name){
+    return function(val, params, curr){
+      storeParam(val, params, curr)
+      var parts = val.split(';');
+      curr[name] = {lat:Number(parts[0]), lon:Number(parts[1])};
+      return curr
+    }
+  }
+
+  var categoriesParam = function (name) {
+    var separatorPattern = /\s*,\s*/g;
+    return function (val, params, curr) {
+      storeParam(val, params, curr)
+      if (curr[name] === undefined)
+        curr[name] = val ? val.split(separatorPattern) : []
+      else
+        if (val)
+          curr[name] = curr[name].concat(val.split(separatorPattern))
+      return curr
+    }
+  }
+
+  // EXDATE is an entry that represents exceptions to a recurrence rule (ex: "repeat every day except on 7/4").
+  // There can be more than one of these in a calendar record, so we create an array of them.
+  // The index into the array is the ISO string of the date itself, for ease of use.
+  // i.e. You can check if ((curr.exdate != undefined) && (curr.exdate[date iso string] != undefined)) to see if a date is an exception.
+  var exdateParam = function (name) {
+      return function (val, params, curr) {
+          var exdate = new Array();
+          dateParam(name)(val, params, exdate);
+          curr[name] = curr[name] || [];
+          curr[name][exdate[name].toISOString()] = exdate[name];
+          return curr;
+      }
+  }
+
+  // RECURRENCE-ID is the ID of a specific recurrence within a recurrence rule.
+  // TODO:  It's also possible for it to have a range, like "THISANDPRIOR", "THISANDFUTURE".  This isn't currently handled.
+  var recurrenceParam = function (name) {
+      return dateParam(name);
+  }
+
+  var addFBType = function (fb, params) {
+    var p = parseParams(params);
+
+    if (params && p){
+      fb.type = p.FBTYPE || "BUSY"
+    }
+
+    return fb;
+  }
+
+  var freebusyParam = function (name) {
+    return function(val, params, curr){
+      var fb = addFBType({}, params);
+      curr[name] = curr[name] || []
+      curr[name].push(fb);
+
+      storeParam(val, params, fb);
+
+      var parts = val.split('/');
+
+      ['start', 'end'].forEach(function (name, index) {
+        dateParam(name)(parts[index], params, fb);
+      });
+
+      return curr;
+    }
+  }
+
+  return {
+
+
+    objectHandlers : {
+      'BEGIN' : function(component, params, curr, stack){
+          stack.push(curr)
+
+          return {type:component, params:params}
+        }
+
+      , 'END' : function(component, params, curr, stack){
+        // prevents the need to search the root of the tree for the VCALENDAR object
+        if (component === "VCALENDAR") {
+            //scan all high level object in curr and drop all strings
+            var key,
+                obj;
+            
+            for (key in curr) {
+                if(curr.hasOwnProperty(key)) {
+                   obj = curr[key];
+                   if (typeof obj === 'string') {
+                       delete curr[key];
+                   }
+                }
+            }
+            
+            return curr
+        }
+        
+        var par = stack.pop()
+
+        if (curr.uid)
+        {
+        	// If this is the first time we run into this UID, just save it.
+        	if (par[curr.uid] === undefined)
+            {
+            	par[curr.uid] = curr;
+            }
+            else
+            {
+                // If we have multiple ical entries with the same UID, it's either going to be a
+                // modification to a recurrence (RECURRENCE-ID), and/or a significant modification
+                // to the entry (SEQUENCE).
+
+                // TODO: Look into proper sequence logic.
+
+                if (curr.recurrenceid === undefined)
+                {
+                    // If we have the same UID as an existing record, and it *isn't* a specific recurrence ID,
+                    // not quite sure what the correct behaviour should be.  For now, just take the new information
+                    // and merge it with the old record by overwriting only the fields that appear in the new record.
+                    var key;
+                    for (key in curr) {
+                    	par[curr.uid][key] = curr[key];
+                    }
+
+                }
+            }
+
+        	// If we have recurrence-id entries, list them as an array of recurrences keyed off of recurrence-id.
+        	// To use - as you're running through the dates of an rrule, you can try looking it up in the recurrences
+        	// array.  If it exists, then use the data from the calendar object in the recurrence instead of the parent
+        	// for that day.
+
+        	// NOTE:  Sometimes the RECURRENCE-ID record will show up *before* the record with the RRULE entry.  In that
+        	// case, what happens is that the RECURRENCE-ID record ends up becoming both the parent record and an entry
+        	// in the recurrences array, and then when we process the RRULE entry later it overwrites the appropriate
+			// fields in the parent record.
+
+        	if (curr.recurrenceid != null)
+        	{
+
+        		// TODO:  Is there ever a case where we have to worry about overwriting an existing entry here?
+
+        		// Create a copy of the current object to save in our recurrences array.  (We *could* just do par = curr,
+        		// except for the case that we get the RECURRENCE-ID record before the RRULE record.  In that case, we 
+        		// would end up with a shared reference that would cause us to overwrite *both* records at the point
+				// that we try and fix up the parent record.)
+        		var recurrenceObj = new Object();
+        		var key;
+        		for (key in curr) {
+        			recurrenceObj[key] = curr[key];
+        		}
+
+        		if (recurrenceObj.recurrences != undefined) {
+        			delete recurrenceObj.recurrences;
+        		}
+
+
+				// If we don't have an array to store recurrences in yet, create it.
+        		if (par[curr.uid].recurrences === undefined) {
+        			par[curr.uid].recurrences = new Array();
+            	}
+
+				// Save off our cloned recurrence object into the array, keyed by date.
+        		par[curr.uid].recurrences[curr.recurrenceid.toISOString()] = recurrenceObj;
+            }
+
+        	// One more specific fix - in the case that an RRULE entry shows up after a RECURRENCE-ID entry,
+        	// let's make sure to clear the recurrenceid off the parent field.
+        	if ((par[curr.uid].rrule != undefined) && (par[curr.uid].recurrenceid != undefined))
+            {
+        		delete par[curr.uid].recurrenceid;
+            }
+
+        }
+        else
+          par[Math.random()*100000] = curr  // Randomly assign ID : TODO - use true GUID
+
+        return par
+      }
+
+      , 'SUMMARY' : storeParam('summary')
+      , 'DESCRIPTION' : storeParam('description')
+      , 'URL' : storeParam('url')
+      , 'UID' : storeParam('uid')
+      , 'LOCATION' : storeParam('location')
+      , 'DTSTART' : dateParam('start')
+      , 'DTEND' : dateParam('end')
+      , 'EXDATE' : exdateParam('exdate')
+      ,' CLASS' : storeParam('class')
+      , 'TRANSP' : storeParam('transparency')
+      , 'GEO' : geoParam('geo')
+      , 'PERCENT-COMPLETE': storeParam('completion')
+      , 'COMPLETED': dateParam('completed')
+      , 'CATEGORIES': categoriesParam('categories')
+      , 'FREEBUSY': freebusyParam('freebusy')
+      , 'DTSTAMP': dateParam('dtstamp')
+      , 'EXDATE': exdateParam('exdate')
+      , 'CREATED': dateParam('created')
+      , 'LAST-MODIFIED': dateParam('lastmodified')
+      , 'RECURRENCE-ID': recurrenceParam('recurrenceid')
+
+    },
+
+
+    handleObject : function(name, val, params, ctx, stack, line){
+      var self = this
+
+      if(self.objectHandlers[name])
+        return self.objectHandlers[name](val, params, ctx, stack, line)
+
+      //handling custom properties
+      if(name.match(/X\-[\w\-]+/) && stack.length > 0) {
+          //trimming the leading and perform storeParam
+          name = name.substring(2);
+          return (storeParam(name))(val, params, ctx, stack, line);
+      }
+      
+      return storeParam(name.toLowerCase())(val, params, ctx);
+    },
+
+
+    parseICS : function(str){
+      var self = this
+      var lines = str.split(/\r?\n/)
+      var ctx = {}
+      var stack = []
+
+      for (var i = 0, ii = lines.length, l = lines[0]; i<ii; i++, l=lines[i]){
+        //Unfold : RFC#3.1
+        while (lines[i+1] && /[ \t]/.test(lines[i+1][0])) {
+          l += lines[i+1].slice(1)
+          i += 1
+        }
+
+        var kv = l.split(":")
+
+        if (kv.length < 2){
+          // Invalid line - must have k&v
+          continue;
+        }
+
+        // Although the spec says that vals with colons should be quote wrapped
+        // in practise nobody does, so we assume further colons are part of the
+        // val
+        var value = kv.slice(1).join(":")
+          , kp = kv[0].split(";")
+          , name = kp[0]
+          , params = kp.slice(1)
+
+        ctx = self.handleObject(name, value, params, ctx, stack, l) || {}
+      }
+
+       // type and params are added to the list of items, get rid of them.
+       delete ctx.type
+       delete ctx.params
+
+       return ctx
+    }
+
+  }
+}))
diff --git a/node-ical.js b/node-ical.js
new file mode 100644
index 0000000..c15c764
--- /dev/null
+++ b/node-ical.js
@@ -0,0 +1,58 @@
+var ical = require('./ical')
+  , request = require('request')
+  , fs = require('fs')
+
+exports.fromURL = function(url, opts, cb){
+  if (!cb)
+    return;
+  request(url, opts, function (err, r, data) {
+  	if (err)
+  	{
+  		return cb(err, null);
+  	}
+    else if (r.statusCode != 200)
+    {
+    	return cb(r.statusCode + ": " + r.statusMessage, null);
+    }
+
+  	cb(undefined, ical.parseICS(data));
+  })
+}
+
+exports.parseFile = function(filename){
+  return ical.parseICS(fs.readFileSync(filename, 'utf8'))
+}
+
+
+var rrule = require('rrule-alt').RRule
+var rrulestr = rrule.rrulestr
+
+ical.objectHandlers['RRULE'] = function(val, params, curr, stack, line){
+  curr.rrule = line;
+  return curr
+}
+var originalEnd = ical.objectHandlers['END'];
+ical.objectHandlers['END'] = function (val, params, curr, stack) {
+	// Recurrence rules are only valid for VEVENT, VTODO, and VJOURNAL.
+	// More specifically, we need to filter the VCALENDAR type because we might end up with a defined rrule 
+	// due to the subtypes.
+	if ((val === "VEVENT") || (val === "VTODO") || (val === "VJOURNAL")) {
+		if (curr.rrule) {
+			var rule = curr.rrule.replace('RRULE:', '');
+			if (rule.indexOf('DTSTART') === -1) {
+
+				if (curr.start.length === 8) {
+					var comps = /^(\d{4})(\d{2})(\d{2})$/.exec(curr.start);
+					if (comps) {
+						curr.start = new Date(comps[1], comps[2] - 1, comps[3]);
+					}
+				}
+
+				rule += ';DTSTART=' + curr.start.toISOString().replace(/[-:]/g, '');
+				rule = rule.replace(/\.[0-9]{3}/, '');
+			}
+			curr.rrule = rrule.fromString(rule);
+		}
+	}
+  return originalEnd.call(this, val, params, curr, stack);
+}