Date.prototype.toLocalFormat = function (theFormat){
  var aVar = {
   MM: this.getMonth()+1,
   DD: this.getDate(),
   YYYY: this.getFullYear(),
   hh: this.getHours(),
   mm: this.getMinutes(),
   ss: this.getSeconds(),
   ap: "AM",
   tz: GetTimezone(this)
  }
  
  if(theFormat.match(/\bap\b/i)){
    if(aVar.hh>12){
      aVar.hh -= 12;
      aVar.ap = "PM";
    }
  }
  
  for(v in aVar){
    theFormat = theFormat.replace(v, f2(aVar[v]));
  }
  
  function f2(theVal){
    if(theVal<10) return "0"+theVal;
    return theVal;
  }
  
  return theFormat;
}

function GetTimezone(date)
{
	var __arrDST = DstDetect();
	var __tzOffset = ((date.getTimezoneOffset() / 60) * -1);
	var __tz = "";
	var __dst = false;
	//debugger;
	if(date > __arrDST[0] && date < __arrDST[1]) {
		__dst = true;
		__tzOffset--;
	}

	switch(__tzOffset)
	{
		case 0:
			__tz = "GMT";
			break;
		case 1:
			__tz = "WAT";
			break;
		case 2:
			__tz = ((__dst) ? "EEDT" : "EET");
			break;
		case 3:
			__tz = "";
			break;
		case -1:
			__tz = ((__dst) ? "" : "WAT");
			break;
		case -2:
			__tz = ((__dst) ? "" : "AT");
			break;
		case -3:
			__tz = "";
			break;
		case -4:
			__tz = ((__dst) ? "ADT" : "AST");
			break;
		case -5:
			__tz = ((__dst) ? "EDT" : "EST");
			break;
		case -6:
			__tz = ((__dst) ? "CDT" : "CST");
			break;
		case -7:
			__tz = ((__dst) ? "MDT" : "MST");
			break;
		case -8:
			__tz = ((__dst) ? "PDT" : "PST");
			break;
		case -9:
			__tz = ((__dst) ? "YDT" : "YST");
			break;
		case -10:
			__tz = ((__dst) ? "HDT" : "HST");
			break;
		case -11:
			__tz = ((__dst) ? "" : "NT");
			break;
	}
	
	return __tz;
}

function TimezoneDetect(){
    var dtDate = new Date('1/1/' + (new Date()).getUTCFullYear());
    var intOffset = 780; //set initial offset high so it is adjusted on the first attempt
    var intMonth;
    var intHoursUtc;
    var intHours;
    var intDaysMultiplyBy;
    
    //go through each month to find the lowest offset to account for DST
    for (intMonth=0;intMonth < 12;intMonth++){
        //go to the next month
        dtDate.setUTCMonth(dtDate.getUTCMonth() + 1);
        
        //To ignore daylight saving time look for the lowest offset. 
        //Since, during DST, the clock moves forward, it'll be a bigger number.
        if (intOffset > (dtDate.getTimezoneOffset() * (-1))){
            intOffset = (dtDate.getTimezoneOffset() * (-1));
        }
    }
 
    return intOffset;
}

//Find start and end of DST
function DstDetect(){
    var dtDstDetect = new Date();
    var dtDstStart = '';
    var dtDstEnd = '';
    var dtDstStartHold = ''; //Temp date hold
    var intYearDayCount = 732; //366 (include leap year) * 2 (for two years)
    var intHourOfYear = 1;
    var intDayOfYear;
    var intOffset = TimezoneDetect(); //Custom function. Make sure you include it.
    
    //Start from a year ago to make sure we include any previously starting DST
    dtDstDetect = new Date()
    dtDstDetect.setUTCFullYear(dtDstDetect.getUTCFullYear() - 1);
    dtDstDetect.setUTCHours(0,0,0,0);
   
    //Going hour by hour through the year will detect DST with shorter code but that could result in 8760 
    //FOR loops and several seconds of script execution time. Longer code narrows this down a little.
    //Go one day at a time and find out approx time of DST and if there even is DST on this computer.
    //Also need to make sure we catch the most current start and end cycle.
    for(intDayOfYear = 1; intDayOfYear <= intYearDayCount; intDayOfYear++){
        dtDstDetect.setUTCDate(dtDstDetect.getUTCDate() + 1);
                    
        if ((dtDstDetect.getTimezoneOffset() * (-1)) != intOffset && dtDstStartHold == ''){
            dtDstStartHold = new Date(dtDstDetect);
        }
        if ((dtDstDetect.getTimezoneOffset() * (-1)) == intOffset && dtDstStartHold != ''){
            dtDstStart = new Date(dtDstStartHold);
            dtDstEnd = new Date(dtDstDetect);
            dtDstStartHold = '';
 
            //DST is being used in this timezone. Narrow the time down to the exact hour the change happens
            //Remove 48 hours (a few extra to be on safe side) from the start/end date and find the exact change point
            //Go hour by hour until a change in the timezone offset is detected.
            dtDstStart.setUTCHours(dtDstStart.getUTCHours() - 48);
            dtDstEnd.setUTCHours(dtDstEnd.getUTCHours() - 48);
            
            //First find when DST starts
            for(intHourOfYear=1; intHourOfYear <= 48; intHourOfYear++){
                dtDstStart.setUTCHours(dtDstStart.getUTCHours() + 1);
                
                //If we found it then exit the loop. dtDstStart will have the correct value left in it.
                if ((dtDstStart.getTimezoneOffset() * (-1)) != intOffset){
                    break;
                }
            }
 
            //Now find out when DST ends
            for(intHourOfYear=1; intHourOfYear <= 48; intHourOfYear++){
                dtDstEnd.setUTCHours(dtDstEnd.getUTCHours() + 1);
                
                //If we found it then exit the loop. dtDstEnd will have the correct value left in it.
                if ((dtDstEnd.getTimezoneOffset() * (-1)) != (intOffset + 60)){
                    break;
                }
            }
            
            //Check if DST is currently on for this time frame. If it is then return these values. 
            //If not then keep going. The function will either return the last values collected 
            //or another value that is currently in effect
            if ((new Date()).getTime() >= dtDstStart.getTime() && (new Date()).getTime() <= dtDstEnd.getTime()){
                return new Array(dtDstStart,dtDstEnd);
            }
 
        }        
    }
    return new Array(dtDstStart,dtDstEnd);
}