/*

* tz.js - Library for working with timezones in JavaScript

* Written in 2011 by L. David Baron <dbaron@dbaron.org>

* To the extent possible under law, the author(s) have dedicated all

* copyright and related and neighboring rights to this software to the

* public domain worldwide. This software is distributed without any

* warranty.

*

* You should have received a copy of the CC0 Public Domain Dedication

* along with this software. If not, see

* <http://creativecommons.org/publicdomain/zero/1.0/>.

*/

/* tz.js @@VERSION@@ ; tzdata @@TZDATA_VERSION@@ */

(function() {

"use strict";

var gZones = @@ZONES@@;

var gLinks = @@LINKS@@;

var is_leap = function(year) {

return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);

}

var gDaysInMonth = [ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ];

var gSecsPerDay = 86400;

var gSecsPerWeek = 604800;

var g_rule_main_re = /^((?:<[^<>]+>)|(?:[^\d:,+-]+))([+-])?(\d{1,2})(:(\d{1,2})(:(\d{1,2}))?)?(.*)/;

var g_rule_dst_re = /^((?:<[^<>]+>)|(?:[^\d:,+-]+))(([+-])?(\d{1,2})(:(\d{1,2})(:(\d{1,2}))?)?)?,([^,]*),([^,]*)$/;

var g_start_end_re = /^([^\/]+)(\/([+-]?\d{1,3})(:(\d{1,2})(:(\d{1,2}))?)?)?$/;

var g_mwd_re = /^M(\d+)\.(\d+)\.(\d+)$/;

var numorz = function(str_or_undefined) {

if (typeof(str_or_undefined) == "undefined") {

return 0;

}

return Number(str_or_undefined);

}

var compute_rule_boundary = function(year, boundary, utc_offset_before) {

var m = boundary.match(g_start_end_re);

var daystr = m[1];

var time;

if (typeof(m[2]) == "undefined") {

// time is implicitly 2am local time

time = 7200;

} else {

time = 3600 * Number(m[3]) + 60 * numorz(m[5]) + numorz(m[7]);

}

// Based on daystr, set |d| to the start of the relevant day in UTC.

var d;

if (daystr[0] == "M") {

m = daystr.match(g_mwd_re);

var month = Number(m[1]);

var week = Number(m[2]);

var weekday = Number(m[3]);

d = Date.UTC(year, month-1) / 1000;

if (week == 5) {

d += (gDaysInMonth[month] - 7) * gSecsPerDay;

} else {

d += (week - 1) * gSecsPerWeek;

}

var weekstartday = (new Date(d * 1000)).getUTCDay();

d += ((weekday - weekstartday + 7) % 7) * gSecsPerDay

} else if (daystr[0] == "J") {

// Julian day, 1-365, never counting Feb. 29

// This means 59 is Feb 28, 60 is Mar 1.

var n = Number(daystr.substr(1));

var j = n - 1 + (n > 59 && is_leap(year));

d = Date.UTC(year, 0) / 1000 + j * gSecsPerDay;

} else {

// Julian day, 0-365, counting Feb. 29 when leap year

var j = Number(daystr);

d = Date.UTC(year, 0) / 1000 + j * gSecsPerDay;

}

return d + time - utc_offset_before;

}

var zone_pair_from_rule = function(rule, d) {

// See http://www.gnu.org/s/hello/manual/libc/TZ-Variable.html

// and the extensions documented in the man page for tzfile(5)

// in the time zone database distribution.

var m = rule.match(g_rule_main_re);

var abbr = m[1];

// In POSIX TZ format, UTC offsets are backwards.

var offset = (3600 * Number(m[3]) + 60 * numorz(m[5]) + numorz(m[7])) *

((m[2] == "-") ? 1 : -1);

var dst_part = m[8];

if (dst_part != "") {

m = dst_part.match(g_rule_dst_re);

var dst_abbr = m[1];

var dst_offset;

if (typeof(m[2]) == "undefined") {

// Optional offset omitted, thus implicitly 1 hour from norm.

dst_offset = offset + 3600;

} else {

dst_offset =

(3600 * Number(m[4]) + 60 * numorz(m[6]) + numorz(m[8])) *

((m[3] == "-") ? 1 : -1);

}

// As of version three of the timezone file format, the

// rules allow an extension in which daylight savings time

// may be indicated as being present all year, by use of a

// transition to daylight savings time at midnight local

// time on January 1, and a transition off of it at 25:00

// local time on December 31. This means as long as we use

// one of offset and dst_offset to pick the year to use,

// even if it's wrong (as it is in the last hour of the year

// in such cases), we'll still get the correct result. (We

// do need to be consistent because we need the same year

// for both computations; otherwise can pick start and end

// in different years and get DST wrong.)

var year = (new Date((d + offset) * 1000)).getUTCFullYear();

var start = compute_rule_boundary(year, m[9], offset);

var end = compute_rule_boundary(year, m[10], dst_offset);

var isdst = ((d < start) ^ (d < end)) ^ (end < start);

if (isdst) {

abbr = dst_abbr;

offset = dst_offset;

}

}

if (abbr[0] == "<" && abbr[abbr.length-1] == ">") {

// Trim the < and >, since they are not present for the

// non-rule case.

abbr = abbr.slice(1, -1);

}

return { offset: offset, abbr: abbr };

}

var zone_pair_from_table = function(zi, d) {

// binary search the list of times

var min = 0, max = zi.times.length - 1; // both inclusive

do {

var idx = min + Math.floor((max - min + 1) / 2);

if (d < zi.times[idx]) {

max = idx - 1;

} else {

min = idx;

}

} while (min != max);

var lttype = zi.types[zi.ltidx[min]];

return { offset: lttype.o, abbr: lttype.a };

}

var public_zoneAt = function(zone, dateObj) {

var czone = public_canonicalName(zone);

if (!czone) {

throw "Invalid time zone name: " + zone;

}

var zi = gZones[czone];

var d = dateObj.valueOf() / 1000;

if (d < 0) {

throw "Dates prior to 1970 not allowed.";

}

// per tzfile(5), the rule, if it exists, is for times after the

// last transition in the file

if (d >= zi.times[zi.times.length-1] && zi.rule) {

return zone_pair_from_rule(zi.rule, d);

}

return zone_pair_from_table(zi, d);

}

var public_datesFor = function(zone, year, month, day, hour, minute,

second) {

// Assume that zones do not change time more than once in any 48

// hour period, and that no zone is more than 24 hours from UTC.

//

// If those assumptions are false, we might fail to return a

// result that we should have returned, but

// make_and_check_result ensures we'll never return an incorrect

// one.

var du = Date.UTC(year, month-1, day, hour, minute, second) / 1000;

var d1 = du - gSecsPerDay;

var d2 = du + gSecsPerDay;

var z1 = public_zoneAt(zone, new Date(d1 * 1000));

var z2 = public_zoneAt(zone, new Date(d2 * 1000));

var results = [];

var make_and_check_result = function(offset) {

var d = du - offset; // our hypothetical date

var date = new Date(d * 1000);

var zi = public_zoneAt(zone, date);

if (zi.offset == offset) {

zi.date = date;

results.push(zi);

}

}

make_and_check_result(z1.offset);

if (z1.offset != z2.offset) {

make_and_check_result(z2.offset);

}

return results;

}

var gAllZones = null;

var public_allZones = function() {

if (!gAllZones) {

var zones = [];

for (var zone in gZones) {

zones.push(zone);

}

zones.sort();

gAllZones = zones;

}

return gAllZones;

}

var public_links = function() {

return gLinks;

}

var public_canonicalName = function(name) {

if (name in gZones) {

return name;

}

return gLinks[name]; // Returns undefined if not present

}

// Exports:

var tz_export = {

/**

* zoneAt(zone, dateObj)

*

* Given a valid named time zone (either a canonical zone name

* or an alias/link) and a JavaScript date object, return a zone

* object with two properties:

* offset: the UTC offset for the zone, in seconds

* abbr: the correct short name for the zone

*

* For example,

* tz.zoneAt("America/Los_Angeles",

* new Date(Date.UTC(1976,6,4,18,0,0)))

* (the time there is 1976-07-04 18:00:00 UTC) should return

* an object like this:

* { offset: -25200, abbr: "PDT" }

* since the America/Los_Angeles time zone observed summer time

* at the time given, and was thus at offset UTC minus 7 hours

* (or 25200 seconds), and used the abbreviation PDT (for

* Pacific Daylight Time).

*/

zoneAt: public_zoneAt,

/**

* datesFor(zone, year, month, day, hour, minute, second)

*

* Given a valid named time zone (either a canonical zone name

* or an alias/link) and a local time with:

* year >= 1970 (but not on January 1, 1970)

* month 1-12 (different from JS months, which are 0-11!)

* day 1-31

* hour 0-23

* minute 0-59

* second 0-59

* returns an *array* of objects with three properties, the two

* described above for zoneAt, and then a "date" property with a

* JavaScript date object. This array may have 0, 1, or 2

* elements (and in theory it may have more in the future,

* though the current code never produces such results).

*

* For example,

* tz.datesFor("America/Los_Angeles", 2011, 1, 1, 0, 0, 0)

* will produce one result:

* [

* { offset: -28800, abbr: "PST", date: (new Date(1293868800000)) }

* ]

* representing the moment of the new year 2011 in Los Angeles.

* This is the common case.

*

* However, around summer time changes zero or two results can

* occur. For example:

* tz.datesFor("America/Los_Angeles", 2011, 3, 13, 2, 30, 0)

* will produce an empty array since the start of summer time

* causes the clock to jump from 2011-03-13 01:59:59 PST to

* 2011-03-13 03:00:00 PDT.

*

* But this example:

* tz.datesFor("America/Los_Angeles", 2011, 11, 6, 1, 30, 0)

* will produce two results:

* [

* { offset: -25200, abbr: "PDT", date: (new Date(1320568200000)) }

* { offset: -28800, abbr: "PST", date: (new Date(1320571800000)) }

* ]

* representing times one hour apart, since the summer time

* change makes the clock jump from 2011-11-06 01:59:59 PDT to

* 2011-11-06 01:00:00 PST, and thus it passes 01:30 twice that

* day.

*/

datesFor: public_datesFor,

/**

* Return an array listing all of the canonical supported named

* time zones, in alphabetical order. The same array will be

* returned from each call.

*

* This is mainly useful if you want to enumerate all supported

* zones.

*/

allZones: public_allZones,

/**

* Return a hash mapping all aliased zone names (links) to their

* canonical zone names. The same object will be returned from

* each call.

*

* You will probably find the canonicalName function below more

* useful.

*/

links: public_links,

/**

* Return the canonical name of a timezone identifier that may

* or may not be an link (alias).

*

* Note that if the timezone database has the given zone as both

* a zone *and* a link, the zone is preferred.

*

* Returns undefined if there is no canonical name.

*

* For example, tz.canonicalName("America/Los_Angeles") will

* return "America/Los_Angeles", since America/Los_Angeles is a

* canonical timezone name. However,

* tz.canonicalName("US/Pacific") will also return

* "America/Los_Angeles" since US/Pacific is an alias for

* America/Los_Angeles. Likewise,

* tz.canonicalName("Africa/Addis_Ababa") will return

* "Africa/Nairobi" since the tz database no longer follows the

* convention that there is one canonical name per country, and

* has therefore made Africa/Addis_Ababa an alias for

* Africa/Nairobi (since both have followed the same time zone

* rules since 1970).

*

* This is useful if you want to canonicalize the timezone

* names. However, it is not required for use of tz.zoneAt or

* tz.datesFor.

*/

canonicalName: public_canonicalName,

};

if (typeof module !== "undefined" && module.exports) {

module.exports = tz_export;

} else {

window.tz = tz_export;

}

})();