/*	file datimlib.js
	Datum & Zeit Funktionen
	made by pstrainer@gmx.net
	Version 2011-12-20
	Anwendung:
		<script type="text/javascript" src="...../library/datimlib.js"></script>
	Sprechende Funktions-Namen, daher wenig Kommentar
	Das Javascript Date() Objekt datim ist die Standard-Drehscheibe,
		alle anderen Formate werden von/in Date() umgewandelt.
	Fast alle Funktionen haben optionale Argumente, 
		viele sind ueberladen (variable Argument-Type).
	Wenn Argumente fehlen, werden Standardwerte angenommen.
	Der Standardwert des datim-Objekts ist die aktuelle Systemzeit.
	Die meisten Funktionen sind optional in einer schnelleren internen 
		Version ohne Validierung verfuegbar.
	Wenn angefuehrt gilt UTC, ansonsten Lokalzeit.
	Funktionsname, die auf x enden, verwenden "simulierte Lokalzeit":
		Das datim-Objekt wird fuer Lokalzeit mit UTC-Funktionen verarbeitet,
		diese Methode ist unabhaengig von einem moeglichen Win-Fehler.

	Standards
	+ JavaScript (JS) Date() object datim
	+ UNIX timestamp uts in sec
	+ Integers YYYY,MO,DD,hh,mi,ss
	+ Standard ISO 8601 string YYYY-MO-DD hh:mi:ss
	+ Standard euro string DD.MO.YYYY hh:mi:ss
	+ Standard RFC-822  string Wdy, DD mon YYYY hh:mi:ss +0100
	+ Standard US string MO/DD/YYYY hh:mi:ss XM
	
	Siehe auch astrolib.js

----- Global Variables -----
	var datimlib_tzoh			TZO in hrs (+ for east of Greenwich)
	var datimlib_dlsh			Current daylight savings in hrs

----- Functions -----
UNIX-Timestamp:
	uts=datim_to_uts(datim);
	datim=uts_to_datim(uts);
JD & MJD:
	jd=ymdhms_to_jd(yy,mo,dd,hh,mi,ss);
	jd=datim_to_jd(datim);
	datim=jd_to_datim(jd);
	mjd=get_mjd(yy,mo,dd);
	mjd=datim_to_mjd(datim);
	datim=mjd_to_datim(mjd);
Y1900 & Y1904 (M$, VB):
	y1900=datim_to_y1900_utc(datim);		// datim -> Y1900 UTC
	y1900=datim_to_y1900_loc(datim);		// datim -> Y1900 Lokalzeit
	datim=y1900_to_datim(y1900);
	y1904=datim_to_y1904(datim);
	datim=y1904_to_datim(y1904);
Filemaker-Funktionen in einer eigenen Datei datimlib_fmp.js
Jahr
	b=leap_year(2000);   oder   b=leap_year(datim);	// Schaltjahr (true/false)
Woche
	woy=week_of_year(datim);
	woyus=week_of_year_us(datim);
Tag
	doy=day_of_year(datim);	// integer
	dow=day_of_week(datim,1);	// integer 1..7
	mildow=mil_doy(datim);   // (yyyy % 10)*1000 + doy
	ndow=weekday_name(datim);	// full name of weekday (ge) 
	ndow=weekday_name(datim,2);	// 2 chars of weekday (ge) 
Tageszeit
	sod_local=datim_to_sod(datim);		// local seconds of day
	sod_utc=datim_to_sod_utc(datim);		// utc seconds of day
Zeitzone
	dh=get_tzo_h();				// konstante diff der Lokalzeit
	dh=get_dlso_h();				// konstante diff der Sommerzeit
	dh=datim_to_tzoh(datim);	// gesamte diff eines beliebigen datim
	dh=get_current_tzo_h();		// gesamte aktuelle diff
	t=tzo_offset_string();		// timezone offset string +0100
	iso+=datim_to_iso_offset(datim);	// timezone offset string +01:00
	tzos=timezone_offset(lon);		// timezone offset in s
	mlo=mean_local_offset(lon);	// mean local offset in s
	mlt=mean_local_time(datim,lon);
Sommerzeit
	datim=daylight_savings_start(yyyy);	// Beginn Sommerzeit
	datim=daylight_savings_start(datim);
	datim=daylight_savings_stop(yyyy);	// Ende Sommerzeit
	datim=daylight_savings_stop(datim);
	dls_h=datim_to_daylight_savings_h(datim);	// (zusaetzlicher) Sommerzeit-Offset in h
Ostern
	datim=easter_date(yy);	// integer year
	iso=easter_date(yy,1);
	datim=easter_date(datim);	// date object
	iso=easter_date(datim,1);
	sb=sonntagsbuchstabe(datim);
	sb=sonntagsbuchstabe(yy);
String:
	iso=datim_to_iso(datim);		// YYYY-MO-DD hh:mi:ss	Lokalzeit -> pstrainer.js
	iso=datim_to_iso_compact(datim);	// YYYYMODDhhmiss	Lokalzeit
	iso=datim_to_iso_date_compact(datim);	// YYYYMODD	Lokalzeit
	iso=datim_to_iso_time_compact(datim);	// hhmiss	Lokalzeit
	iso=datim_to_iso_doy(datim);	// YYYY-DDD	Lokalzeit
	iso=datim_to_iso_utc(datim);	// YYYY-MO-DD hh:mi:ss UTC
	iso=datim_to_iso_utc_date(datim);	// YYYY-MO-DD UTC
	iso=datim_to_iso_utc_time(datim);	// hh:mi:ss UTC
	iso=week_of_year_iso(datim);		// YYYY-Www
	iso=day_of_year_iso(datim);		// YYYY-DDD
	iso=seconds_to_time_string(sec);	// integer seconds -> hh:mi:ss
	datim=iso_to_datim(iso,ds);	// integer offset ds in seconds
	din=datim_to_din5008(datim,1);	// DIN 5008 (Varianten)
	s=myLocaleString(datim);	// Wochentag, DD.Monat YYYY hh:mi:ss
	datim=rfc_to_datim(rfc);	// Wkd, DD Mon YYYY hh:mi:ss +tzo
	rfc=datim_to_rfc(datim);	// (Varianten)
	ed=datim_to_eurodate(datim,mode);	// DD.MO.YYYY hh:mi:ss (mode>0 -> fuehrende Nullen)
	usdate=datim_to_usdate(datim);	// MO/DD/YYYY
	ustime=datim_to_ustime(datim);	// hh:mi:ss *M
	iso=usdatim_to_iso(us);		// mm/dd/yyyy hh:mi:ss -> pstrainer.js
	iso=rfc_to_iso(rfc);		// Day, dd Mon yyyy hh:mi:ss +0100 -> pstrainer.js
Swatch Internet Time:
	s=datim_to_swatch_string(datim);	// @bbb
	beats=datim_to_swatch_beats(datim);
*/
//alert("datimlib a");

//########## Array data ##########
var datimlib_wtn=new Array("Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag","Sonntag");
var datimlib_mon=new Array("J\u00E4nner","Februar","M\u00E4rz","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember");
var datimlib_weekday_array=new Array("Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday");
var datimlib_wd_array=new Array("Sun","Mon","Tue","Wed","Thu","Fri","Sat");
var datimlib_me_array=new Array("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec");
//########## UNIX Timestamp ##########

function datim_to_uts() {
// UNIX Timestamp in s
// Verwendung: uts=datim_to_uts(datim); (verwendet getTimezoneOffset)
// uts=datim_to_uts(datim,tzos); (verwendet tzos / UTC)
	var uts=0;
	var d=null;
	if (datim_to_uts.arguments.length > 0) {d=datim_to_uts.arguments[0];}
	if(!d) {d=new Date();}
	if (datim_to_uts.arguments.length > 1) {
		var tzos=datim_to_uts.arguments[1];
		uts=datim_to_utsx$(d,tzos);
	}
	else {uts=datim_to_uts$(d);}
	return uts;
}
function datim_to_uts$(d) {
// internal calculation
	datimlib_uts=Math.round(d.getTime()/1000);
	return datimlib_uts;
}
function datim_to_utsx$(d,tzos) {
// internal calculation
	var dx=new Date(d.getTime());
	dx.setSeconds(dx.getSeconds()-tzos);
	datimlib_uts=Math.round(dx.getTime()/1000);
	return datimlib_uts;
}

function uts_to_datim() {
// datim aus einem UNIX timestamp (beides in UTC)
// Verwendung: datim=uts_to_datim(uts);
// Verwendung: datix=uts_to_datim(uts,tzos);
//	erzeugt ein Pseudo-Datim (um tzos spaeter) der aktuellen Zeit
	if(uts_to_datim.arguments.length>0) {
		var uts=uts_set.arguments[0];
		var tzos=0;
		if(uts_to_datim.arguments.length>1) {tzos=uts_set.arguments[1];}
		var d=new Date().setTime(uts*1000+tzos);
		return d;		
	}
	else{return new Date();}
}

//############### JD & MJD ###############

function ymdhms_to_jd() {
// calc julian day jd
// Verwendung: jd=ymdhms_to_jd(yy,mo,dd,hh,mi,ss) ## in UTC !! ##
	var a=ymdhms_to_jd.arguments.length;
	var d=null;
	if(a<6) {d=new Date();}
	var yy=null; var mo=null; var dd=null;
	var hh=null; var mi=null; var ss=null;
	// Optionale Argumente
	if (a>0) {yy=ymdhms_to_jd.arguments[0];}
	else {yy=d.getUTCFullYear();}
	if (a>1) {mo=ymdhms_to_jd.arguments[1];}
	else {mo=d.getUTCMonth()+1;}
	if (a>2) {dd=ymdhms_to_jd.arguments[2];}
	else {dd=d.getUTCDate();}
	if (a>3) {hh=ymdhms_to_jd.arguments[3];}
	else {hh=d.getUTCHours();}
	if (a>4) {mi=ymdhms_to_jd.arguments[4];}
	else {mi=d.getUTCMinutes();}
	if (a>5) {ss=ymdhms_to_jd.arguments[5];}
	else {ss=d.getUTCSeconds();}
	jd=ymdhms_to_jd$(yy,mo,dd,hh,mi,ss);
	return jd;
}
function ymdhms_to_jd$(yy,mo,dd,hh,mi,ss) {
// internal calculation yy,mo,dd,hh,mi,ss -> jd
	var gregdat=(14+31*(10+12*1582));	// 588828;
	var jd=null;
	// Jahr
	if(yy<0) yy++;	// Jahr<0
	// Monat
	var ma=0;
	if(mo>2) {ma=mo+1;}
	else{yy--; ma=mo+13;}
	jd=ceilfloor(Math.floor(365.25*yy)+Math.floor(30.6001*ma)+dd+1720995);
	// GregDat Korrektur 
	if(dd+31*(mo+12*yy) >= gregdat) {
		var ja=ceilfloor(yy/100);
		jd+=2-ja+ceilfloor(ja/4);
	}	
	// Zeit
	var mytim=hh+mi/60+ss/3600;
	mytim=(mytim/24)-0.5;
	jd+=mytim;
	//
	return jd;
}

function datim_to_jd() {
// JS datim object from julian day jd 
// Verwendung: jd=datim_to_jd(datim);
// Verwendung: jd=datim_to_jd(datix,tzos);
	var d=null;
	if (datim_to_jd.arguments.length>0) {d=datim_to_jd.arguments[0];}
	if(!d) {d=new Date();}
	if (datim_to_jd.arguments.length>1) {
		var tzos=datim_to_jd.arguments[1];
		d.setSeconds(d.getSeconds()+tzos);
	}
	var jd=0;
	if(d.getUTCFullYear()<1970) {jd=datim_to_jd$(d);}
	else {jd=datim_to_jd_short$(d);}
	return jd;
}
function datim_to_jd_short$(d) {
	var uts=d.getTime()/1000;
	jd=uts/86400+2440587.5;
	return jd;
}
function datim_to_jd$(d) {
// internal calculation of datim -> jd
	var jd=ymdhms_to_jd$(d.getUTCFullYear(),d.getUTCMonth()+1,d.getUTCDate(),d.getUTCHours(),d.getUTCMinutes(),d.getUTCSeconds());
	return jd;
}

function jd_to_datim() {
// Calc jd -> JS datim object
// Verwendung: datim=jd_to_datim(jd);
// Verwendung: datim=jd_to_datim(jd,tzos);
	var jd=null; var d=null;
	if (jd_to_datim.length>0) {
		jd=jd_to_datim.arguments[0];
		if(jd_to_datim.length>1) {
			var tzos=jd_to_datim.arguments[1];
			jd+=tzos/86400;
		}
		if(jd>2440600) {d=jd_to_datim_short$(jd);}
		else {d=jd_to_datim$(jd);}
	}
	if(!jd) {d=new Date();}
	return d;
}
function jd_to_datim_short$(jd) {
	var uts=(jd-2440587.5)*86400;
	my_dt=new Date(uts*1000);
	return my_dt;
}
function jd_to_datim$(jd) {
// internal calculation of jd -> datim
	var my_dt=null;
	var rest=jd+32044;
	var y400=Math.floor(rest/146097);
	rest=dmodulo(rest,146097);
	var y100=my_minimum(3,Math.floor(rest/36524));
	rest= rest-36524*y100;
	var y4 =Math.floor(rest/1461);
	rest=dmodulo(rest,1461);
	var y1=my_minimum(3,Math.floor(rest/365));
	rest=rest-365*y1;
	var my_yy=(y400-12)*400+y100*100+y4*4+y1;
	var m0=Math.floor((rest*111+41)/3395);
	rest=rest-30*m0-Math.floor((m0+1)*7/12)+1;
	var my_dd=Math.floor(rest+0.5);
	m0=m0+3;
	var my_mo=((m0+11)%12)+1;
	my_yy=my_yy+Math.floor(m0/13);
	// time
	rest=(rest-my_dd)*24;
	var my_hh=Math.floor(rest);
	rest=(rest-my_hh)*60;
	var my_mi=Math.floor(rest);
	rest=(rest-my_mi)*60;
	var my_ss=Math.round(rest);
	my_hh=my_hh+12;
	// datim object
	var uts=Date.UTC(my_yy,my_mo-1,my_dd,my_hh,my_mi,my_ss);
	my_dt=new Date(uts);
	return my_dt;
}

function ymd_to_mjd() {
// Calc MJD (default = system)
// Verwendung: mjd=get_mjd(yy,mo,dd);
	var a=ymd_to_mjd.arguments.length;
	var d=null;
	var yy=null; var mo=null; var dd=null;
	if(a<3) {d=new Date();}
	if (a>0) {yy=ymd_to_mjd.arguments[0];}
	else {yy=d.getUTCFullYear();}
	if (a>1) {mo=ymd_to_mjd.arguments[1];}
	else {mo=d.getUTCMonth()+1;}
	if (a>2) {dd=ymd_to_mjd.arguments[2];}
	else {dd=d.getUTCDate();}
	var mjd=ymd_to_mjd$(yy,mo,dd);
	return mjd;
}
function ymd_to_mjd$(yy,mo,dd) {
// internal calculation yy,mo,dd -> mjd
	var mjd=Math.round(ymdhms_to_jd$(yy,mo,dd,0,0,0)-2400000.5);
	return mjd;
}

function datim_to_mjd() {
// Verwendung: mjd=datim_to_mjd(datim);
	var d=null;
	if (datim_to_mjd.arguments.length > 0) {d=datim_to_mjd.arguments[0];}
	if(!d) {d=new Date();}
	var mjd=datim_to_mjd$(d);
	return mjd;
}
function datim_to_mjd$(d) {
// internal calculation of datim -> jd
	var mjd=ymd_to_mjd$(d.getUTCFullYear(),d.getUTCMonth()+1,d.getUTCDate());
	return mjd;
}

function mjd_to_datim() {
// Calc mjd -> JS datim object
// Verwendung: datim=mjd_to_datim(mjd);
	var mjd=null; var d=null;
	if (mjd_to_datim.arguments.length > 0) {
		mjd=mjd_to_datim.arguments[0];
		d=mjd_to_datim$(mjd);
	}
	if(!mjd) {d=new Date();}
	return d;
}
function mjd_to_datim$(mjd) {
// internal calculation of mjd -> datim
	var jd=mjd+2400000.5;
	var d=jd_to_datim$(jd);
	return d;
}

//############### Y1900 & Y1904 ###############

function datim_to_y1900_utc() {
// converts js date object to vba y1900 format (vba)
// Verwendung: y1900utc=datim_to_y1900_utc(datim);
// Verwendung: y1900utc=datim_to_y1900_utc(datix,tzos);
	var d=null;
	if (datim_to_y1900_utc.arguments.length > 0) {d=datim_to_y1900_utc.arguments[0];}
	if(!d) {d=new Date();}
	if (datim_to_y1900_utc.arguments.length > 1) {
		var tzos=datim_to_y1900_utc.arguments[1];
		d.setSeconds(d.getSeconds()+tzos);
	}
	var y1900=datim_to_y1900_utc$(d);
	return y1900;	
}
function datim_to_y1900_utc$(d) {
// internal calculation
	var uts=datim_to_uts$(d);
	//uts+=(datimlib_tzoh*3600);
	var y1900=uts/86400+25569;
	return y1900;	
}
function datim_to_y1900_loc() {
// converts js date object to vba y1900 format (vba)
// Verwendung: y1900loc=datim_to_y1900_loc(datim);
	var d=null;
	if (datim_to_y1900_loc.arguments.length>0) {d=datim_to_y1900_loc.arguments[0];}
	if(!d) {d=new Date();}
	var y1900=datim_to_y1900_loc$(d);
	return y1900;	
}
function datim_to_y1900_loc$(d) {
// internal calculation
	var uts=datim_to_uts$(d);
	var h1=d.getHours();
	var h2=d.getUTCHours();
	uts+=((h1-h2)*3600);
	var y1900=uts/86400+25569;
	return y1900;	
}
function datim_to_y1900() {
	alert("function datim_to_y1900 is deprecated !");
}

function y1900_to_datim() {
// converts vba Y1900 to js date object
// no check for date < 1970 !!!
// Verwendung: datim=y1900_to_datim(y1900);
	if (y1900_to_datim.arguments.length > 0) {
		var d=y1900_to_datim$(y1900_to_datim.arguments[0]);
	}
	else {var d=new Date();}
	return d;
}
function y1900_to_datim$(y1900) {
// internal calculation y1900 -> datim UTC
	var d=new Date();
	var uts=(y1900-25569)*86400;
	uts*=1000;
	d.setTime(uts);
	return d;
}
function y1900_to_datim_loc$(y1900) {
// internal calculation y1900 -> local datim
	var d=new Date();
	var uts=(y1900-25569)*86400;
	uts-=(datimlib_tzoh*3600.0);
	uts*=1000;
	d.setTime(uts);
	return d;
}

function datim_to_y1904() {
// converts js date object to y1904 format
// Verwendung: y1904=datim_to_y1904(datim);
	var d=null;
	if (datim_to_y1904.arguments.length > 0) {d=datim_to_y1904.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_y1904$(d);	
}
function datim_to_y1904$(d) {
// internal calculation datim -> y1904
	var uts=datim_to_uts$(d);
	//uts+=(datimlib_tzoh*3600.0);
	var y1904=uts/86400.0+24107.0;
	return y1904;	
}

function y1904_to_datim() {
// converts Y1904 to js date object
// no check for date < 1970 !!!
// Verwendung: datim=y1904_to_datim(y1904);
	if (y1904_to_datim.arguments.length > 0) {
		return y1904_to_datim$(y1904_to_datim.arguments[0]); 
	}
	else {return new Date();}
}
function y1904_to_datim$(y1904) {
// internal calculation y1904 -> datim
	var d=null;
	var uts=(y1904-24107)*86400;
	//uts-=(datimlib_tzoh*3600.0);
	uts*=1000;
	try{d.setTime(uts);}
	catch(e) {}
	return d;
}

// ########## Jahr ##########

function leap_year() {
// Return leap-year (true or false)
// Argument: either date object or integer year numberr
// Verwendung: b=leap_year(2000);   oder   b=leap_year(datim);
	var yy=0;
	var sy=false;
	if (leap_year.arguments.length>0) {
		var arg0=leap_year.arguments[0];
		if(typeof arg0=="number") {
			yy=arg0;
			if(yy<1000) {yy+=1900;}
		}
		else {yy=arg0.getFullYear();}
	}
	else {yy=new Date().getFullYear();}
	if(yy<=1600) {sy=null;}
	else {sy=leap_year$(yy);}
	return sy;
}
function leap_year$(yy) {
// internal calculation
	var sy=false;
	if(yy<=1600) {yy=null;}
	if((yy % 400)==0) {sy=true;}
	else if((yy % 100)!=0) {
		if((yy % 4)==0) {sy=true;}
	}
	return sy;
}

// ########## Kalenderwoche ##########

function week_of_year() {
// ISO-KW
// Verwendung: woy=week_of_year(datim);
	var d=null;
	if (week_of_year.arguments.length>0) {d=week_of_year.arguments[0];}
	if(!d) {d=new Date();}
	return week_of_year$(d);
}
function week_of_year$(d) {
// internal calculation
	var utsd=d.getTime();
	var dif=utsd-week_of_year_ref$(d.getUTCFullYear());
	if(dif<0) {	// Vorjahr
		dif=utsd-week_of_year_ref$(d.getUTCFullYear()-1);
	}
	else if(dif>358) {
		var difnext=utsd-week_of_year_ref$(d.getUTCFullYear()+1);
		if(difnext>=0) {dif=difnext;}
	}
	var kw=Math.floor(dif/604800000)+1;	// 86400*1000*7
	return kw;
}
function week_of_year_ref$(yy) {
// internal calculation of woy reference date timestamp
	var uts=Date.UTC(yy,0,4);
	var dow=new Date(uts).getDay();
	if(dow==0) {dow+=7;}
	return uts-(dow-1)*86400000;
}

function week_of_year_iso() {
// ISO-KW-String YYYY-Www
// Verwendung: woy=week_of_year(datim);
	var d=null;
	if (week_of_year_iso.arguments.length>0) {d=week_of_year_iso.arguments[0];}
	if(!d) {d=new Date();}
	return week_of_year_iso$(d);
}
function week_of_year_iso$(d) {
	var t=d.getUTCFullYear().toString()+"-W";
	var woy=week_of_year$(d);
	if(woy<10) {t+="0";}
	return t+woy.toString();
}

function week_of_year_us() {
// US-KW
// Verwendung: woyus=week_of_year_us(datim);
	var d=null;
	if (week_of_year_us.arguments.length>0) {d=week_of_year_us.arguments[0];}
	if(!d) {d=new Date();}
	return week_of_year_us$(d);
}
function week_of_year_us$(d) {
// internal calculation
	var utsd=d.getTime();
	var dif=utsd-week_of_year_usref$(d.getUTCFullYear());
	return Math.floor(dif/604800000)+1;
}
function week_of_year_usref$(yy) {
// internal calculation of us-woy reference date
	var uts=Date.UTC(yy,0,1);
	var dow=new Date(uts).getDay();
	return uts-dow*86400000;
}

// ########## Tag des Jahres ##########

function day_of_year_iso() {
// returns ISO-string YYYY-DDD
// Verwendung: iso=day_of_year_iso(datim);
	d=null;
	if (day_of_year_iso.arguments.length>0) {d=day_of_year_iso.arguments[0];}
	if(!d) {d=new Date();}
	return day_of_year_iso$(d);
}
function day_of_year_iso$(d) {
	var t=d.getUTCFullYear()+"-";
	var doy=day_of_year$(d);
	if(doy<100) {t+="0";}
	if(doy<10) {t+="0";}
	return t+doy.toString();
}

function day_of_year() {
// returns integer day of year (1..366)
// Verwendung: doy=day_of_year(datim);
	d=null;
	if (day_of_year.arguments.length>0) {d=day_of_year.arguments[0];}
	if(!d) {d=new Date();}
	return day_of_year$(d);
}
function day_of_year$(d) {
// internal calculation
	var yy=d.getFullYear();
	var t2=new Date(yy,d.getMonth(),d.getDate());
	var t1=new Date(yy-1,11,31);
	// Runden wegen Sommerzeit !
	var doy=Math.round((t2.getTime()/1000-t1.getTime()/1000)/86400);
	return doy;
}

function mil_doy() {
// returns (yyyy % 10)*1000 + doy
// Verwendung: mildoy=mil_doy(datim);
	d=null;
	if (mil_doy.arguments.length>0) {d=mil_doy.arguments[0];}
	if(!d) {d=new Date();}
	return mil_doy$(d);
}
function mil_doy$(d) {
// internal calculation
	var m=(d.getFullYear() % 10)*1000+day_of_year$(d);
	return m;
}
// ########## Wochentag ##########

function day_of_week() {
// returns integer weekday-nr 0..7 (e=0 @ USA, e=1 @ EU, e=2 @ MySQL)
// Verwendung: dow=day_of_week(datim,e);
// e=0   Mo=1 ... Sa=6, So=0   (Javascript,US)
// e=1   Mo=1 ... Sa=6, So=7   (EU)
// e=2   So=1 ... Sa=7         (MySQL)
	var d=null;
	if (day_of_week.arguments.length>0) {d=day_of_week.arguments[0];}
	if(!d) {d=new Date();}
	var e=1;	// default = EU
	if (day_of_week.arguments.length>1) {
		e=day_of_week.arguments[1];
		if(e<0 || e>2) {e=1;}
	}
	return day_of_week$(d,e);
}
function day_of_week$(d,e) {
// internal calculation
	var wd=d.getDay();
	if(wd==0) {if(e==1) {wd=7;}}
	if(e==2) {wd++;}
	return wd;
}

function weekday_name() {
// Verwendung:
// ndow=weekday_name(datim); -> full name of weekday (ge) 
// ndow=weekday_name(datim,2); -> 2 chars of weekday (ge) 
	var d=null;
	if(weekday_name.arguments.length>0) {d=weekday_name.arguments[0];}
	if(!d) {d=new Date();}
	var c=0;
	if(weekday_name.arguments.length>1) {c=parseInt(weekday_name.arguments[1],10);}
	return weekday_name$(d,c);
}
function weekday_name$(d,c) {
// internal calculation 
	var dow=day_of_week$(d);
	return weekday_name$$(dow,c);
}
function weekday_name$$(dow,c) {
// internal calculation 
	var wdn=datimlib_wtn[dow];
	if(c>0) {wdn=wdn.substr(0,c);}
	return wdn;
}

// ########## Tageszeit ##########

function datim_to_sod() {
// local seconds of day
// Verwendung: sod_local=datim_to_sod(datim);
	var d=null;
	if(datim_to_sod.arguments.length>0) {d=datim_to_sod.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_sod$(d);
}
function datim_to_sod$(d) {
// internal calculation 
	return datim_to_sod0$(d)-d.getTimezoneOffset()*60;
}
function datim_to_sod_utc() {
// UTC seconds of day
// Verwendung: sod_utc=datim_to_sod_utc(datim);
	var d=null;
	if(datim_to_sod_utc.arguments.length>0) {d=datim_to_sod_utc.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_sod_utc$(d);
}
function datim_to_sod_utc$(d) {
// UTC seconds of day
	var uts=d.getTime();
	var uts0=Date.UTC(d.getUTCFullYear(),d.getUTCMonth(),d.getUTCDate());
	return (uts-uts0)/1000;
}

// ########## Zeitzone ##########

function datim_to_tzoh(d) {
// Offset eines beliebigen datim-Objekts in h
// (Zeitzone + Sommerzeit)
// Verwendung: dh=datim_to_tzoh(datim);
	return -(d.getTimezoneOffset()/60);
}
function get_tzo_h() {
// konstanter Offset der lokalen Zeitzone
// Verwendung: dh=get_tzo_h();
// Nach dem Laden Korrektur des Gecko@Windows Fehlers !
	return -new Date(2000,0,1).getTimezoneOffset()/60;
}
function get_dlso_h() {
// konstanter zusaetzlicher Offset der Sommerzeit
// Verwendung: dh=get_dlso_h();
	var my_tzoh=datimlib_tzoh();
	var my_dloh=-new Date(2000,6,1).getTimezoneOffset()/60-my_tzoh;
	return my_dloh;
}
function get_current_tzo_h() {
// aktueller Offset in h (Zeitzone + Sommerzeit)
// Verwendung: dh=get_current_tzo();
	return -new Date().getTimezoneOffset()/60;
}
function get_current_dlso_h() {
// aktueller Offset der Sommerzeit in h
// besser: x=servertime_tzoh-datimlib_tzoh;
	var x=get_current_tzo_h()-datimlib_tzoh;
	return x;
}
function tzo_offset_string() {
// returns current timezone offset string in format +0100
// Verwendung: t=tzo_offset_string();
	var hof=-new Date().getTimezoneOffset() / 60;
	return tzo_offset_string$$(hof);
}
function tzo_offset_stringx(tzos) {
// returns current timezone offset string in format +0100
// Verwendung: t=tzo_offset_stringx(tzos);
	var hof=tzos/3600;
	return tzo_offset_string$$(hof);
}
function tzo_offset_string$$(hof) {
	var tzos=(hof>=0 ? "+" : "");
	tzos+=datim_n2(hof)+"00";
	return tzos;
}

function datim_to_iso_offset() {
// offset string +01:00 zum Anhaengen an die ISO-Zeit
// Verwendung: iso+=datim_to_iso_offset(datim);
	var d=null;
	if(datim_to_iso_offset.arguments.length>0) {d=datim_to_iso_offset.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_iso_offset$(d);
}
function datim_to_iso_offset$(d) {
// internal calculation -> format +01:00
	var sof=-d.getTimezoneOffset()*60;
	var iso="+";
	if(sof<0) {iso="-";}
	iso+=seconds_to_time_string$(Math.abs(sof),2);
	return iso;
}

function timezone_offset(lon) {
// tzos=timezone_offset(lon);
	var tzos=Math.round(lon/15)*3600;
	return tzos;
}
function mean_local_offset_utc(lon) {
// Differenz der mittlere Ortszeit zur UTC in sec
// mlo=mean_local_offset_utc(lon);
	var sdif=lon/15*3600;
	return sdif;
}
function mean_local_offset(lon) {
// Differenz der mittleren Ortszeit zur Zonenzeit in sec
// mlo=mean_local_offset(lon);
	var sdif=(lon/15-Math.round(lon/15))*3600;
	return sdif;
}
function mean_local_time() {
// Mittlere Ortszeit einer  Zeit als Funktion der geogr.Laenge
// Laenge in grad oestl.Gw
// datim=mean_local_time(datim,lon);
	var d=null; var lon=0;
	if (mean_local_time.arguments.length > 0) {d=mean_local_time.arguments[0];}
	if (mean_local_time.arguments.length > 1) {lon=mean_local_time.arguments[1];}
	if(!d) {d=new Date();}
	return mean_local_time$(d,lon);
}
function mean_local_time$(d,lon) {
	var hdif=(lon/15-Math.round(lon/15));
	var uts=d.getTime()+hdif*3600000;
	d.setTime(uts);
	return d;
}

// ########## Sommerzeit ##########

function daylight_savings_start() {
// Sommerzeit-beginn als Date object
// Argument: int Jahreszahl oder Date-Objekt (leer -> aktuelles Jahr) 
// Verwendung: datim=daylight_savings_start(2000);
// Verwendung: datim=daylight_savings_start(datim);
	var yy=null;
	if(daylight_savings_start.arguments.length>0) {
		var arg0=daylight_savings_start.arguments[0];
		if((typeof arg0)=="object") {yy=arg0.getUTCFullYear();}
		else if((typeof arg0)=="number") {yy=Math.floor(arg0);}
	}
	if(!yy) {yy=new Date().getUTCFullYear();}
	var ref=daylight_savings_date$(yy,3);
	return ref;
}

function daylight_savings_stop() {
// Sommerzeit-Ende als Date object
// Argument: int Jahreszahl oder Date-Objekt (leer -> aktuelles Jahr) 
// Verwendung: datim=daylight_savings_start(2000);
// Verwendung: datim=daylight_savings_start(datim);
	var yy=null;
	if(daylight_savings_stop.arguments.length>0) {
		var arg0=daylight_savings_stop.arguments[0];
		if((typeof arg0)=="object") {yy=arg0.getUTCFullYear();}
		else if((typeof arg0)=="number") {yy=Math.floor(arg0);}
	}
	if(!yy) {yy=new Date().getUTCFullYear();}
	var ref=daylight_savings_date$(yy,10);
	return ref;
}

function daylight_savings_date$(yy,mo) {
// InterneVerwendung - Sommerzeit-Ref-Datum
// yy-> Jahr, mo->[3,10]
	var ref=null;
	if(mo==3 || mo==10) {
		var utc=Date.UTC(yy,mo,1);	// 1.April || 1.Nov
		ref=new Date(utc);
		var dow=day_of_week$(ref,1);
		utc-=(dow*24-1)*3600*1000;
		ref=new Date(utc);
	}
	else {
		alert("Fehler in daylight_savings_date$: mo="+mo+" ist unzul\u00E4ssig. ");
	}
	return ref;
}

function datim_to_daylight_savings_h() {
// Sommerzeit-Offset eines Datum-Objekts in Stunden
// Verwendung: dls_h=datim_to_daylight_savings(datim);
	var d=null;
	if(datim_to_daylight_savings.arguments.length>0) {d=datim_to_daylight_savings.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_daylight_savings$(d);
}

function datim_to_daylight_savings_h$(d) {
	var dls_h=0; var ref=null;
	var yy=0; var dd=0; var hh=0; var utc=0; var dow=0;
	var mo=d.getMonth()+1;
	if(mo>3 && mo<10) {dls_h=1;}	// Sommer
	else if(mo==3) {	// Maerz
		dd=d.getDate();
		if(dd>24) {
			yy=d.getFullYear();
			ref=daylight_savings_date$(yy,3);
			dif=d-ref;
			if(dif>=0) {dls_h=1;}
		}
	}
	else if(mo==10) {	// Oktober
		dd=d.getDate();
		if(dd<24) {dls_h=1;}
		else {
			yy=d.getFullYear();
			ref=daylight_savings_date$(yy,10);
			dif=d-ref;
			if(dif<0) {dls_h=1;}
		}
	}
	return dls_h;
}

// ########## Ostern ##########

function easter_date() {
// Oster-Datum als Date object oder iso-string
// Argument 1: int Jahreszahl oder Date-Objekt (leer -> aktuelles Jahr) 
// Argument 2 steuert Rueckgabe: 0(default)-> Date-Objekt, 1->ISO-string
// Verwendung: datim=easter_date(2000);
// Verwendung: iso=easter_date(datim,1);
	var yy=null; var algopt=0;
	if(easter_date.arguments.length>0) {
		var arg0=easter_date.arguments[0];
		if((typeof arg0)=="object") {yy=arg0.getUTCFullYear();}
		else if((typeof arg0)=="number") {yy=Math.floor(arg0);}
	}
	if(!yy) {yy=new Date().getUTCFullYear();}
	if(easter_date.arguments.length>0) {algopt=parseInt(easter_date.arguments[1],10);}
	if(isNaN(algopt) || algopt<0) {algopt=0;}
//alert("easter_date\nyy="+yy+"\nalgopt="+algopt);
	return easter_date$(yy,algopt);
}
function easter_date$(yy,algopt) {
// internal calculation
	var cent = ((Math.floor(yy/100))+1); 
	var cx = ((Math.floor((3*cent)/4))-12);
	var cz = ((Math.floor((8*cent+5)/25))-5); 
	var gold = ((yy % 19) + 1);
	var sun = ((Math.floor((5*yy)/4))-cx-10);
	var epact = (((11*gold)+20+cz-cx)%30);
	if (epact < 0) {epact=epact+30;}
	if (((epact==25)&&(gold>11))||(epact==24)) {epact++;} 
	moon = 44 - epact;
	if (moon < 21) {moon+=30;}
	moon = (moon + 7 - ((sun + moon) % 7)); 
	var mm=0; 
	var dd=0;
	if (moon > 31) {mm = 4; dd = (moon - 31);}
	else {mm = 3; dd = moon;}
	var datim=null;
	if(algopt>0) {datim=yy.toString()+"-"+num2str_2(mm)+"-"+num2str_2(dd);}
	else {
		var uts=Date.UTC(yy,mm-1,dd,0,0,0);
		datim=new Date(uts);
	}
	return datim;
}

function sonntagsbuchstabe() {
// Sonntagsbuchstabe fuer Osterformel
// Verwendung mit datim-Objekt oder Jahreszahl
// sb=sonntagsbuchstabe(datim);;
// sb=sonntagsbuchstabe(yy);
	var yy=null;
	if(sonntagsbuchstabe.arguments.length>0) {
		var arg0=sonntagsbuchstabe.arguments[0];
		if((typeof arg0)=="object") {yy=arg0.getUTCFullYear();}
		else if((typeof arg0)=="number") {yy=Math.floor(arg0);}
	}
	if(!yy) {yy=new Date().getUTCFullYear();}
	return sonntagsbuchstabe$(yy);
}
function sonntagsbuchstabe$(yy) {
// internal calculation
	var uts=Date.UTC(yy,0,1);
	var wdnr=new Date(uts).getDay();
	if(wdnr==0) {wdnr=7;}
	var sb=String.fromCharCode(72-wdnr);
	return sb;
}

//########## String functions ##########
//	function datim_to_iso(datim)
//	This function has moved to pstrainer.js

//---------- Erzeugung von ISO-8601-Strings in Weltzeit UTC aus DaTim-Objekten ----------

//	Diese haeufig verwendeten Funktionen sind -> pstrainer.js ausgelagert:
//	iso=datim_to_iso(datim);
// iso=datim_to_iso_date(datim);
// iso=datim_to_iso_time(datim);

function datim_to_iso_compact(datim) {
// Make ISO 8601 date & time string YYYYMODDhhmiss from a JS date object
// Verwendung: iso=datim_to_iso_compact(datim);
	d=null;
	if (datim_to_iso_compact.arguments.length>0) {d=datim_to_iso_compact.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_iso_compact$(d);		
}
function datim_to_iso_compact$(d) {
// internal calculation datim -> string YYYYMODDhhmiss
	var iso=datim_to_iso_date_compact$(d);
	iso+=datim_to_iso_time_compact$(d);
	return iso;		
}

function datim_to_iso_date_compact(datim) {
// Make ISO 8601 date & time string YYYYMODD from a JS date object
// Verwendung: iso=datim_to_iso_date_compact(datim);
	d=null;
	if (datim_to_iso_date_compact.arguments.length>0) {d=datim_to_iso_date_compact.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_iso_date_compact$(d);		
}
function datim_to_iso_date_compact$(d) {
// internal calculation datim -> string YYYYMODD
	var iso="";
	iso+=d.getFullYear().toString();
	iso+=num2str_2(d.getMonth()+1);
	iso+=num2str_2(d.getDate());
	return iso;		
}

function datim_to_iso_time_compact(datim) {
// Make ISO 8601 date & time string hhmiss from a JS date object
// Verwendung: iso=datim_to_iso_time_compact(datim);
	d=null;
	if (datim_to_iso_time_compact.arguments.length>0) {d=datim_to_iso_time_compact.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_iso_time_compact$(d);		
}
function datim_to_iso_time_compact$(d) {
// internal calculation datim -> string hhmiss
	var iso="";
	iso+=num2str_2(d.getHours());
	iso+=num2str_2(d.getMinutes());
	iso+=num2str_2(d.getSeconds());
	return iso;		
}

function datim_to_iso_doy() {
// returns ISO-String YY-DDD
// Verwendung: iso=datim_to_iso_doy(datim);
	d=null;
	if (datim_to_iso_doy.arguments.length>0) {d=datim_to_iso_doy.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_iso_doy$(d);
}
function datim_to_iso_doy$(d) {
// internal calculation datim -> doy
	var iso=d.getUTCFullYear().toString()+"-";
	var doy="000"+day_of_year$(d).toString();
	iso+=doy.substr(doy.length-3,3);
	return iso;
}
//---------- Erzeugung von ISO-8601-Strings in Weltzeit UTC aus DaTim-Objekten ----------
function datim_to_iso_utc() {
// Make ISO 8601 UTC date & time string from a JS date object
// Verwendung: iso=datim_to_iso_utc(datim);
	d=null;
	if (datim_to_iso_utc.arguments.length>0) {d=datim_to_iso_utc.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_iso_utc$(d);		
}
function datim_to_iso_utcx() {
// Make ISO 8601 UTC date & time string from a JS date object (virtual local time)
// Verwendung: iso=datim_to_iso_utc(datim,tzos);
	var dx=null; var tzos=0;
	if (datim_to_iso_utcx.arguments.length>0) {dx=datim_to_iso_utcx.arguments[0];}
	if (datim_to_iso_utcx.arguments.length>1) {tzos=datim_to_iso_utcx.arguments[1];}
	if(!dx) {
		dx=new Date();
		dx.setSeconds(dx.getSeconds()+tzos);
	}
	var dy=new Date(dx.getTime());
	dy.setSeconds(dy.getSeconds()-tzos);
	return datim_to_iso_utc$(dy);		
}
function datim_to_iso_utc$(d) {
// internal calculation datim -> YYYY-MO-DD hh:mi:ss
	var iso=datim_to_iso_utc_date$(d);
	iso+=" "+datim_to_iso_utc_time$(d);
	return iso;		
}
function datim_to_iso_utcx$(dx,tzos) {
// internal calculation datim -> YYYY-MO-DD hh:mi:ss
	var dy=new Date(dx.getTime());
	dy.setSeconds(dy.getSeconds()-tzos);
	return datim_to_iso_utc$(dy);		
}

function datim_to_iso_utc_date() {
// Make ISO 8601 UTC date string from a JS date object
// Verwendung: iso=datim_to_iso_utc_date(datim);
	d=null;
	if (datim_to_iso_utc_date.arguments.length>0) {d=datim_to_iso_utc_date.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_iso_utc_date$(d);		
}
function datim_to_iso_utc_datex() {
// Make ISO 8601 UTC date string from a JS date object (virtual local time)
// Verwendung: iso=datim_to_iso_utc_datex(datim,tzos);
	var dx=null; var tzos=0;
	if (datim_to_iso_utc_datex.arguments.length>0) {dx=datim_to_iso_utc_datex.arguments[0];}
	if (datim_to_iso_utc_datex.arguments.length>1) {tzos=datim_to_iso_utc_datex.arguments[1];}
	if(!dx) {
		dx=new Date();
		dx.setSeconds(dx.getSeconds()+tzos);
	}
	var dy=new Date(dx.getTime());
	dy.setSeconds(dy.getSeconds()-tzos);
	return datim_to_iso_utc_date$(dy);		
}
function datim_to_iso_utc_date$(d) {
// internal calculation datim -> YYYY-MO-DD hh:mi:ss
	var iso=d.getUTCFullYear().toString();
	iso+="-"+num2str_2(d.getUTCMonth()+1);
	iso+="-"+num2str_2(d.getUTCDate());
	return iso;		
}
function datim_to_iso_utc_datex$(dx,tzos) {
// internal calculation datim -> YYYY-MO-DD hh:mi:ss
	var dy=new Date(dx.getTime());
	dy.setSeconds(dy.getSeconds()-tzos);
	return datim_to_iso_utc_date$(dy);	
}
function datim_to_iso_utc_time() {
// Make ISO 8601 UTC time string from a JS date object
// Verwendung: iso=datim_to_iso_utc_time(datim);
	d=null;
	if (datim_to_iso_utc_time.arguments.length>0) {d=datim_to_iso_utc_time.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_iso_utc_time$(d);		
}
function datim_to_iso_utc_timex() {
// Make ISO 8601 UTC time string from a JS date object (virtual local time)
// Verwendung: iso=datim_to_iso_utc_timex(datim,tzos);
	var dx=null; var tzos=0;
	if (datim_to_iso_utc_timex.arguments.length>0) {dx=datim_to_iso_utc_timex.arguments[0];}
	if (datim_to_iso_utc_timex.arguments.length>1) {tzos=datim_to_iso_utc_timex.arguments[1];}
	if(!dx) {
		dx=new Date();
		dx.setSeconds(dx.getSeconds()+tzos);
	}
	var dy=new Date(dx.getTime());
	dy.setSeconds(dy.getSeconds()-tzos);
	return datim_to_iso_utc_time$(dy);		
}
function datim_to_iso_utc_time$(d) {
// internal calculation datim -> YYYY-MO-DD hh:mi:ss
	var iso=num2str_2(d.getUTCHours());
	iso+=":"+num2str_2(d.getUTCMinutes());
	iso+=":"+num2str_2(d.getUTCSeconds());
	return iso;		
}
function datim_to_iso_utc_timex$(dx,tzos) {
	var dy=new Date(dx.getTime());
	dy.setSeconds(dy.getSeconds()-tzos);
	return datim_to_iso_utc_time$(dy);	
}


function seconds_to_time_string() {
// returns time-string hh:mi:ss from integer seconds
// Verwendung: iso=seconds_to_time_string(sec);
	arg0=null; ss=null;
	if (seconds_to_time_string.arguments.length>0) {
		arg0=seconds_to_time_string.arguments[0];
		if((typeof arg0)=="number") {ss=arg0;}
		else if((typeof arg0)=="object") {ss=arg0.getSeconds();}
	}
	if(!ss) {ss=new Date().getSeconds();}
	return seconds_to_time_string$(ss,3);
}
function seconds_to_time_string$(s,o) {
// internal calculation: o=1->hh, o=2->hh:mi, o=3->hh:mi:ss
	var t=""; var n=0; var r=0;
	if(s<0) {t="-"; s=-s;}
	n=Math.floor(s/3600);	// h
	t+=num2str_2(n);
	if(o>1) {
		r=s-n*3600;
		n=Math.floor(r/60);	// m
		t+=":"+num2str_2(n);
	}
	if(o>2) {
		r=r-n*60;
		n=Math.round(r);	// s
		t+=":"+num2str_2(n);
	}
	return t;
}

function iso_to_datim() {
// Verwendung: datim=iso_to_datim("2000-12-31 12:34:56");
// +/- Diff in sec:   datim=iso_to_datim(iso,123);
	var t=null;
	if(iso_to_datim.arguments.length > 0) {t=iso_to_datim.arguments[0];}
	if(t) {
		t=strip_controlchars(t);
		if(t.length<4) {t=null;}
	}
	var ds=0;
	if (iso_to_datim.arguments.length > 1) {ds=iso_to_datim.arguments[1];}
	if(t) {return iso_to_datim$(t,ds);}
	else {return new Date();}
}
function iso_to_datim$(t,ds) {
// internal calculation YYYYMODD hh:mi:ss -> datim
	var c=t.length;
	var yy=0;
	if(c>=4) {yy=parseInt(t.substr(0,4),10);}
	else {yy=new Date().getFullYear();}
	var mo=0;
	if(c>=7) {mo=parseInt(t.substr(5,2),10)-1;}
	var dd=1;
	if(c>=10) {dd=parseInt(t.substr(8,2),10);}
	var hh=0;
	if(c>=13) {hh=parseInt(t.substr(11,2),10);}
	var mi=0;
	if(c>=16) {mi=parseInt(t.substr(14,2),10);}
	var ss=0;
	if(c>=19) {ss=parseInt(t.substr(17,2),10);}
	ss+=ds;
	d=new Date(yy,mo,dd,hh,mi,ss);
	return d;
}

// ---------- DIN 5008 ----------

function datim_to_din5008() {
// Make DIN 5008 local date string from a JS date object
// Verwendung: din=datim_to_din5008(datim,1);
	var o=1; var d=null;
	if (datim_to_din_5008.arguments.length>0) {d=datim_to_din_5008.arguments[0];}
	if (datim_to_din_5008.arguments.length>1) {o=datim_to_din_5008.arguments[1];}
	if(o<1 || o>4) {o=1;}
	if(!d) {d=new Date();}
	return datim_to_din5008$(d,o);		
}
function datim_to_din5008$(d,o) {
	var din="";
	if(o<10) {var yy=d.getFullYear(); var mo=d.getMonth()+1; var dd=d.getDate();}
	else {var hh=d.getHours(); var mi=d.getMinutes(); var ss=d.getSeconds();}
	switch (o) {
	case 1:	// dd.mo.yyyy
		din=num2str_2(dd)+"."+num2str_2(mo)+"."+yy.toString(); break;
	case 2:	// d.m.yyyy
		din=dd.toString()+"."+mo.toString()+"."+yy.toString(); break;
	case 3:	// dd.mo.yy
		din=num2str_2(dd)+"."+num2str_2(mo)+"."+num2str_2((yy % 100)); break;
	case 4:	// d.m.yy
		din=dd.toString()+"."+mo.toString()+"."+num2str_2((yy % 100)); break;
	case 5:	// d. Monat yyyy
		din=dd.toString()+". "+datimlib_mon[mo-1]+" "+yy.toString(); break;
	case 6:	// d. Mon. yyyy
		din=dd.toString()+". "+datimlib_mon[mo-1].substr(0,3)+". "+yy.toString(); break;
	case 11:	// hh:mi:ss
		din=num2str_2(hh)+":"+num2str_2(mi)+":"+num2str_2(ss); break;
	case 12:	// hh:mi
		din=num2str_2(hh)+":"+num2str_2(mi); break;
	case 13:	// hh.mi.ss
		din=num2str_2(hh)+"."+num2str_2(mi)+"."+num2str_2(ss); break;
	case 14:	// h.mi
		din=hh.toString()+"."+num2str_2(mi); break;
	}
	return din;
}

// ---------- toLocaleString ----------

function myLocaleString() {
//	Replaces JavaScript method:  thestring=thedate.toLocaleString();
// Wochentag, DD.Monat YYYY hh:mi:ss
// Verwendung:  s=myLocaleString(datim);
	d=null; var myls="";
	if (myLocaleString.arguments.length>0) {d=myLocaleString.arguments[0];}
	if(!d) {d=new Date();}
	var wdnr=day_of_week$(d,1);
	myls+=datimlib_wtn[wdnr]+", ";
	myls+=d.getDate().toString()+".";
	myls+=datimlib_mon[d.getMonth()]+" ";
	myls+=d.getFullYear().toString()+" ";
	myls+=num2str_2(d.getHours())+":";
	myls+=num2str_2(d.getMinutes())+":";
	myls+=num2str_2(d.getSeconds());
	return myls;
}

// --------------- RFC-822 ---------------

function rfc_to_datim(rfc) {
// decode RFC-822 string -> JS Date object
// Thu, 25 Mar 2004 12:34:56 +0100
// -> dd,mm,yyyy,hh,mi,ss,tz
// if the match fails, the current date is returned
	var datim=new Date();
	var res = rfc.match(/, (\d?\d) (...) (\d?\d?\d\d) (\d?\d):(\d?\d):(\d?\d)/);
	if(res) {
		var dd=parseInt(RegExp.$1,10);
		var mmstr=RegExp.$2;
		var mm=1;
		for(var i=0;i<12;i++) {if(mmstr==monam_array[i]) {mm=i+1;} }
		var yy=parseInt(RegExp.$3,10);
		if(yy<1900) {
			if(yy>60) {yy+=1900;}
			else {yy+=2000;}
		}
		var hh=parseInt(RegExp.$4,10);
		var mi=parseInt(RegExp.$5,10);
		var ss=parseInt(RegExp.$6,10);
		// Date-object
		datim.setUTCFullYear(yy);
		datim.setUTCMonth(mm-1);
		datim.setUTCDate(dd);
		datim.setUTCHours(hh);
		datim.setUTCMinutes(mi);
		datim.setUTCSeconds(ss);
	}
	return datim;
}

function datim_to_rfc() {
// Verwendung: rfc=datim_to_rfc(datim,option);
// 1-> Thu, 25 Mar 2004 12:34:56 +0100
	var d=null; var o=1;
	if (datim_to_rfc.arguments.length>0) {d=datim_to_rfc.arguments[0];}
	if (datim_to_rfc.arguments.length>1) {o=datim_to_rfc.arguments[1];}
	//if(o<1 || o>1) {o=1;}
	if(!d) {d=new Date();}
	return datim_to_rfc$(d,o);	
}
function datim_to_rfcx() {
// Verwendung: rfc=datim_to_rfcx(datim,option,tzos);
// option Varianten siehe unten datim_to_rfc$
	var dx=null; var o=1; var tzos=0;
	if (datim_to_rfcx.arguments.length>0) {dx=datim_to_rfcx.arguments[0];}
	if (datim_to_rfcx.arguments.length>1) {o=datim_to_rfcx.arguments[1];}
	if (datim_to_rfcx.arguments.length>2) {tzos=datim_to_rfcx.arguments[2];}
	//if(o<1 || o>1) {o=1;}
	if(!dx) {
		dx=new Date();
		dx.setSeconds(dx.getSeconds()+tzos);
	}
	return datim_to_rfcx$(dx,o,tzos);	
}
function datim_to_rfc$(d,o) {
// internal calculation
// 1-> Thu, 25 Mar 2004 12:34:56 +0100
// 2-> Thu, 25 Mar 2004 12:34:56 GMT          -> RFC 850, RFC 1036
// 3-> Sun Mar 26 12:34:56 2006                  UTC
// 4-> Sun Nov 6 01:12:45 2006	              -> ANSI C function asctime() in Lokalzeit
// 5-> Sunday, 06-Nov-94 08:49:37 GMT         -> RFC 850, RFC 1036
// 6-> Weekday, dd-mon-yyyy hh:mi:ss
// date only:
// 11-> Thu, 25 Mar 2004
// 12-> Thu, 25 Mar 2004
// 13-> Sun Mar 26
// 14-> Sun Nov 6
// 15-> Sunday, 06-Nov-94
// 16-> Weekday, dd-mon-yyyy
	var rfc="*rfc*";
	if(o<=1 || o==11) {	// Fri, 8 May 1998 15:57:33 +0100 (CET)
		rfc=datimlib_wd_array[d.getDay()]+",";
		rfc+=" "+datim_n2(d.getDate());
		rfc+=" "+datimlib_me_array[d.getMonth()];
		rfc+=" "+d.getFullYear().toString();
		if(o<=1) {
			rfc+=" "+datim_to_iso_time(d)+" ";
			try{rfc+=servertime_tzotxt;}
			catch(e) {rfc+=tzo_offset_string(d);}
			// rfc+=" (CET)";
		}
	}
	else if(o==2 || o==12) {	// Thu, 25 Mar 2004 12:34:56 GMT
		rfc=datimlib_wd_array[d.getUTCDay()]+",";
		rfc+=" "+datim_n2(d.getUTCDate());
		rfc+=" "+datimlib_me_array[d.getUTCMonth()];
		rfc+=" "+d.getUTCFullYear().toString();
		if(o==2) {
			rfc+=" "+datim_to_iso_utc_time(d);
			rfc+=" GMT";
		}
	}
	else if(o==3 || o==13) {	// Sun Nov 6 08:49:37 1994	// als UTC
		rfc=datimlib_wd_array[d.getUTCDay()];
		rfc+=" "+datimlib_me_array[d.getUTCMonth()];
		rfc+=" "+d.getUTCDate().toString();
		if(o==3) {
			rfc+=" "+datim_to_iso_utc_time(d);
			rfc+=" "+d.getUTCFullYear().toString();
		}
	}
	else if(o==4 || o==14) {	// Sun Nov 6 08:49:37 1994	// als Lokalzeit
		rfc=datimlib_wd_array[d.getDay()];
		rfc+=" "+datimlib_me_array[d.getMonth()];
		rfc+=" "+d.getDate().toString();
		if(o==4) {
			rfc+=" "+datim_to_iso_time(d);
			rfc+=" "+d.getFullYear().toString();
		}
	}
	else if(o==5 || o==15) {	// Sunday, 06-Nov-94 08:49:37 GMT
		rfc=datimlib_weekday_array[d.getUTCDay()]+",";
		rfc+=" "+datim_n2(d.getUTCDate());
		rfc+="-"+datimlib_me_array[d.getUTCMonth()];
		rfc+="-"+datim_n2(d.getUTCFullYear()%100);
		if(o==5) {
			rfc+=" "+datim_to_iso_time(d);
			rfc+=" GMT";
		}
	}
	else if(o==6 || o==16) {	// Weekday, dd-mon-yyyy hh:mi:ss
		rfc=datimlib_weekday_array[d.getUTCDay()]+",";
		rfc+=" "+datim_n2(d.getDate());
		rfc+="-"+datimlib_me_array[d.getMonth()];
		rfc+="-"+datim_n2(d.getFullYear()%100);
		if(o==6) {
			rfc+=" "+datim_to_iso_time(d);
		}
	}
	return rfc;	
}
function datim_to_rfcx$(dx,o,tzos) {
// internal calculation
// 1-> Thu, 25 Mar 2004 12:34:56 +0100
// 2-> Thu, 25 Mar 2004 12:34:56 GMT
// 3-> Sun Mar 26 12:34:56 2006	// UTC
// 4-> Sun Mar 26 12:34:56 2006	// Lokalzeit
	//var du=dx;
	//du.setSeconds(du.getSeconds-tzos);	// Rueckrechnung der virtuellen Lokalzeit
	var rfc="";
	if(o<=1) {
		rfc+=datimlib_wd_array[dx.getUTCDay()]+",";
		rfc+=" "+datim_n2(dx.getUTCDate());
		rfc+=" "+datimlib_me_array[dx.getUTCMonth()];
		rfc+=" "+dx.getUTCFullYear().toString();
		rfc+=" "+datim_to_iso_timex(dx,tzos)+" ";
		rfc+=tzo_offset_stringx(tzos);
		if(o==4) {rfc+=" (CET)";}	// Fri, 8 May 1998 15:57:33 +0100 (CET)
	}
	else if(o==2) {
		var dy=new Date(dx.getTime());
		dy.setSeconds(dy.getSeconds()-tzos);
		rfc+=datimlib_wd_array[dy.getUTCDay()]+",";
		rfc+=" "+datim_n2(dy.getUTCDate());
		rfc+=" "+datimlib_me_array[dy.getUTCMonth()];
		rfc+=" "+dy.getUTCFullYear().toString();
		rfc+=" "+datim_to_iso_utc_timex(dy);
		rfc+=" GMT"
	}
	else if(o==3) {	// Sun Nov 6 08:49:37 1994	// als UTC
		var dy=new Date(dx.getTime());
		dy.setSeconds(dy.getSeconds()-tzos);
		rfc+=datimlib_wd_array[dy.getUTCDay()];
		rfc+=" "+datimlib_me_array[dy.getUTCMonth()];
		rfc+=" "+dy.getUTCDate().toString();
		rfc+=" "+datim_to_iso_utc_timex(dy);
		rfc+=" "+dy.getUTCFullYear().toString();
	}
	else if(o==4) {	// Sun Nov 6 08:49:37 1994	// als Lokalzeit
		rfc+=datimlib_wd_array[dx.getUTCDay()];
		rfc+=" "+datimlib_me_array[dx.getUTCMonth()];
		rfc+=" "+dx.getUTCDate().toString();
		rfc+=" "+datim_to_iso_timex(dx);
		rfc+=" "+dx.getUTCFullYear().toString();
	}
	else if(o==5) {	// Sunday, 06-Nov-94 08:49:37 GMT
		rfc+=datimlib_weekday_array[dx.getUTCDay()]+",";
		rfc+=" "+datim_n2(dx.getUTCDate());
		rfc+="-"+datimlib_me_array[dx.getUTCMonth()];
		rfc+="-"+datim_n2(dx.getUTCFullYear()%100);
		rfc+=" "+datim_to_iso_time(dx);
		rfc+=" GMT";
	}
	return rfc;	
}

function datim_to_eurodate() {
// JS object -> DD.MM.YYYY hh:mi:ss
// Verwendung: ed=datim_to_eurodate(datim,mode);
// mode 1->fuehrende Nullen (default=0)
	var d=null;
	if (datim_to_eurodate.arguments.length>0) {d=datim_to_eurodate.arguments[0];}
	if(!d) {d=new Date();}
	var m=0;
	if (datim_to_eurodate.arguments.length>1) {m=datim_to_eurodate.arguments[1];}
	return datim_to_eurodate$(d,m);
}
function datim_to_eurodate$(d,m) {
// internal calculation
	var e="";
	if(m>0) {
		e+=num2str_2(d.getDate());
		e+="."+num2str_2(d.getMonth()+1);
	}
	else {
		e+=d.getDate().toString();
		e+="."+(d.getMonth()+1).toString();
	}
	e+="."+d.getFullYear().toString();
	e+=" "+num2str_2(d.getHours());
	e+=":"+num2str_2(d.getMinutes());
	e+=":"+num2str_2(d.getSeconds());
	return e;
}

//########## US-Datum & Zeit-String ##########

function datim_to_usdate() {
// JS object -> MO/DD/YYYY
// Verwendung: usdate=datim_to_usdate(datim);	// MO/DD/YYYY
	d=null;
	if (datim_to_usdate.arguments.length>0) {d=datim_to_usdate.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_usdate$(d);
}
function datim_to_usdate$(d) {
// internal calculation
	var us=(d.getMonth()+1).toString()+"/"+d.getDate().toString()+"/"+d.getFullYear().toString();
	return us;
}

function datim_to_ustime() {
// Die hoechst eigenartige US-Zeit mit hh=[01..12]
// Verwendung: ustime=datim_to_ustime(datim);	// hh:mi:ss *M
	d=null;
	if (datim_to_ustime.arguments.length>0) {d=datim_to_ustime.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_ustime$(d);
}
function datim_to_ustime$(d) {
// internal calculation
	var ush=datim_to_ush$(d);	// Array
	var us=datim_n2(ush[0])+":";
	us+=datim_n2(d.getMinutes())+":";
	us+=datim_n2(d.getSeconds())+" "+ush[1];	// AM,PM
	return us;
}
function datim_to_ustimex$(dx) {
// internal calculation
	var ush=datim_to_ushx$(dx);	// Array
	var us=datim_n2(ush[0])+":";
	us+=datim_n2(dx.getUTCMinutes())+":";
	us+=datim_n2(dx.getUTCSeconds())+" "+ush[1];	// AM,PM
	return us;
}
function datim_to_ush$(d) {
// returns array[us_hh,us_ampm]
	var ush = new Array();
	var us_hh=d.getHours();
	var usapm="";
	if(us_hh<=12) {usapm="AM";}
	else {{usapm="PM";}}
	if(us_hh>12) {us_hh-=12;}
	if(us_hh==0) {us_hh=12;}
	ush[0]=us_hh;
	ush[1]=usapm;
	return ush;
}
function datim_to_ushx$(dx) {
// returns array[us_hh,us_ampm]
	var ush = new Array();
	var us_hh=dx.getUTCHours();
	var usapm="";
	if(us_hh<=12) {usapm="AM";}
	else {{usapm="PM";}}
	if(us_hh>12) {us_hh-=12;}
	if(us_hh==0) {us_hh=12;}
	ush[0]=us_hh;
	ush[1]=usapm;
	return ush;
}

function usdatim_to_datim(us) {
// decode US-date-time string -> JS Date object
// mm/dd/yyyy hh:mi:ss
// if the match fails, the current date is returned
	var datim=new Date();
	var res = us.match(/(\d?\d)\/(\d?\d)\/(\d?\d?\d\d) (\d?\d):(\d?\d):(\d?\d)/);
	if(res) {
		var mm=parseInt(RegExp.$1,10);
		var dd=parseInt(RegExp.$2,10);	
		var yy=parseInt(RegExp.$3,10);
		if(yy<1900) {
			if(yy>60) {yy+=1900;}
			else {yy+=2000;}
		}
		var hh=parseInt(RegExp.$4,10);
		var mi=parseInt(RegExp.$5,10);
		var ss=parseInt(RegExp.$6,10);
		// Date-object
		datim.setUTCFullYear(yy);
		datim.setUTCMonth(mm-1);
		datim.setUTCDate(dd);
		datim.setUTCHours(hh);
		datim.setUTCMinutes(mi);
		datim.setUTCSeconds(ss);
	}
	return datim;
}

//########## Swatch Internet Time ##########

function datim_to_swatch_string() {
// Swatch Internet Time als String @sss
// Verwendung: s=datim_to_swatch_string(datim);
	var d=null;
	if(datim_to_swatch_string.arguments.length>0) {d=datim_to_swatch_string.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_swatch_string$(d);
}
function datim_to_swatch_string$(d) {
	var s=Math.floor(datim_to_swatch_beats$(d));
	var s="000"+s.toString();
	s.match(/(.{3})$/);
	s="@"+RegExp.$1;
	return s;
}

function datim_to_swatch_beats(d) {
// Swatch Internet Time als Zahl (0..beats..1000) - nicht gerundet !
// Verwendung: beats=datim_to_swatch_beats(datim);
	var d=null;
	if(datim_to_swatch_beats.arguments.length>0) {d=datim_to_swatch_beats.arguments[0];}
	if(!d) {d=new Date();}
	return datim_to_swatch_beats$(d);
}
function datim_to_swatch_beats$(d) {
	//var u=d.getTime()+3600000;
	//var db=new Date();
	//db.setTime(d.getTime()+3600000);
	var db=datim_to_biel$(d);
	var s=(db.getUTCHours()+db.getUTCMinutes()/60+db.getUTCSeconds()/3600)/24*1000;
	return s;
}
function datim_to_biel$(d) {
	var u=d.getTime()+3600000;
	var db=new Date();
	db.setTime(d.getTime()+3600000);
	return db;
}

// Interne Hilfsfunktion
function datim_n2(i) {
// make a 2-character string from any number 0..i..99
	return (i<10 ? "0" : "")+i.toString();
}

// ########## Setting global variables #########
// Problems with Gecko Browsers (Firefox) @ Windows !
var datimlib_tzoh=get_tzo_h();

//alert("datimlib z");

// ########## eof datimlib.js #############################################################