1#@!#!123s

22527 1#@!#!123s
: / var / www / html / webadmin / assets / libs / flot / examples / axes-time-zones /
Filename : date.js
back
// -----
// The `timezoneJS.Date` object gives you full-blown timezone support, independent from the timezone set on the end-user's machine running the browser. It uses the Olson zoneinfo files for its timezone data.
//
// The constructor function and setter methods use proxy JavaScript Date objects behind the scenes, so you can use strings like '10/22/2006' with the constructor. You also get the same sensible wraparound behavior with numeric parameters (like setting a value of 14 for the month wraps around to the next March).
//
// The other significant difference from the built-in JavaScript Date is that `timezoneJS.Date` also has named properties that store the values of year, month, date, etc., so it can be directly serialized to JSON and used for data transfer.

/*
 * Copyright 2010 Matthew Eernisse (mde@fleegix.org)
 * and Open Source Applications Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Credits: Ideas included from incomplete JS implementation of Olson
 * parser, "XMLDAte" by Philippe Goetz (philippe.goetz@wanadoo.fr)
 *
 * Contributions:
 * Jan Niehusmann
 * Ricky Romero
 * Preston Hunt (prestonhunt@gmail.com)
 * Dov. B Katz (dov.katz@morganstanley.com)
 * Peter Bergström (pbergstr@mac.com)
 * Long Ho
 */
(function () {
  // Standard initialization stuff to make sure the library is
  // usable on both client and server (node) side.

  var root = this;

  var timezoneJS;
  if (typeof exports !== "undefined") {
    timezoneJS = exports;
  } else {
    timezoneJS = root.timezoneJS = {};
  }

  timezoneJS.VERSION = "1.0.0";

  // Grab the ajax library from global context.
  // This can be jQuery, Zepto or fleegix.
  // You can also specify your own transport mechanism by declaring
  // `timezoneJS.timezone.transport` to a `function`. More details will follow
  var $ = root.$ || root.jQuery || root.Zepto,
    fleegix = root.fleegix,
    // Declare constant list of days and months. Unfortunately this doesn't leave room for i18n due to the Olson data being in English itself
    DAYS = (timezoneJS.Days = [
      "Sunday",
      "Monday",
      "Tuesday",
      "Wednesday",
      "Thursday",
      "Friday",
      "Saturday",
    ]),
    MONTHS = (timezoneJS.Months = [
      "January",
      "February",
      "March",
      "April",
      "May",
      "June",
      "July",
      "August",
      "September",
      "October",
      "November",
      "December",
    ]),
    SHORT_MONTHS = {},
    SHORT_DAYS = {},
    EXACT_DATE_TIME = {},
    TZ_REGEXP = new RegExp("^[a-zA-Z]+/");

  //`{ "Jan": 0, "Feb": 1, "Mar": 2, "Apr": 3, "May": 4, "Jun": 5, "Jul": 6, "Aug": 7, "Sep": 8, "Oct": 9, "Nov": 10, "Dec": 11 }`
  for (var i = 0; i < MONTHS.length; i++) {
    SHORT_MONTHS[MONTHS[i].substr(0, 3)] = i;
  }

  //`{ "Sun": 0, "Mon": 1, "Tue": 2, "Wed": 3, "Thu": 4, "Fri": 5, "Sat": 6 }`
  for (i = 0; i < DAYS.length; i++) {
    SHORT_DAYS[DAYS[i].substr(0, 3)] = i;
  }

  //Handle array indexOf in IE
  if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (el) {
      for (var i = 0; i < this.length; i++) {
        if (el === this[i]) return i;
      }
      return -1;
    };
  }

  // Format a number to the length = digits. For ex:
  //
  // `_fixWidth(2, 2) = '02'`
  //
  // `_fixWidth(1998, 2) = '98'`
  //
  // This is used to pad numbers in converting date to string in ISO standard.
  var _fixWidth = function (number, digits) {
    if (typeof number !== "number") {
      throw "not a number: " + number;
    }
    var s = number.toString();
    if (number.length > digits) {
      return number.substr(number.length - digits, number.length);
    }
    while (s.length < digits) {
      s = "0" + s;
    }
    return s;
  };

  // Abstraction layer for different transport layers, including fleegix/jQuery/Zepto
  //
  // Object `opts` include
  //
  // - `url`: url to ajax query
  //
  // - `async`: true for asynchronous, false otherwise. If false, return value will be response from URL. This is true by default
  //
  // - `success`: success callback function
  //
  // - `error`: error callback function
  // Returns response from URL if async is false, otherwise the AJAX request object itself
  var _transport = function (opts) {
    if (
      (!fleegix || typeof fleegix.xhr === "undefined") &&
      (!$ || typeof $.ajax === "undefined")
    ) {
      throw new Error(
        "Please use the Fleegix.js XHR module, jQuery ajax, Zepto ajax, or define your own transport mechanism for downloading zone files."
      );
    }
    if (!opts) return;
    if (!opts.url) throw new Error("URL must be specified");
    if (!("async" in opts)) opts.async = true;
    if (!opts.async) {
      return fleegix && fleegix.xhr
        ? fleegix.xhr.doReq({ url: opts.url, async: false })
        : $.ajax({ url: opts.url, async: false }).responseText;
    }
    return fleegix && fleegix.xhr
      ? fleegix.xhr.send({
          url: opts.url,
          method: "get",
          handleSuccess: opts.success,
          handleErr: opts.error,
        })
      : $.ajax({
          url: opts.url,
          dataType: "text",
          method: "GET",
          error: opts.error,
          success: opts.success,
        });
  };

  // Constructor, which is similar to that of the native Date object itself
  timezoneJS.Date = function () {
    var args = Array.prototype.slice.apply(arguments),
      dt = null,
      tz = null,
      arr = [];

    //We support several different constructors, including all the ones from `Date` object
    // with a timezone string at the end.
    //
    //- `[tz]`: Returns object with time in `tz` specified.
    //
    // - `utcMillis`, `[tz]`: Return object with UTC time = `utcMillis`, in `tz`.
    //
    // - `Date`, `[tz]`: Returns object with UTC time = `Date.getTime()`, in `tz`.
    //
    // - `year, month, [date,] [hours,] [minutes,] [seconds,] [millis,] [tz]: Same as `Date` object
    // with tz.
    //
    // - `Array`: Can be any combo of the above.
    //
    //If 1st argument is an array, we can use it as a list of arguments itself
    if (Object.prototype.toString.call(args[0]) === "[object Array]") {
      args = args[0];
    }
    if (
      typeof args[args.length - 1] === "string" &&
      TZ_REGEXP.test(args[args.length - 1])
    ) {
      tz = args.pop();
    }
    switch (args.length) {
      case 0:
        dt = new Date();
        break;
      case 1:
        dt = new Date(args[0]);
        break;
      default:
        for (var i = 0; i < 7; i++) {
          arr[i] = args[i] || 0;
        }
        dt = new Date(arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6]);
        break;
    }

    this._useCache = false;
    this._tzInfo = {};
    this._day = 0;
    this.year = 0;
    this.month = 0;
    this.date = 0;
    this.hours = 0;
    this.minutes = 0;
    this.seconds = 0;
    this.milliseconds = 0;
    this.timezone = tz || null;
    //Tricky part:
    // For the cases where there are 1/2 arguments: `timezoneJS.Date(millis, [tz])` and `timezoneJS.Date(Date, [tz])`. The
    // Date `dt` created should be in UTC. Thus the way I detect such cases is to determine if `arr` is not populated & `tz`
    // is specified. Because if `tz` is not specified, `dt` can be in local time.
    if (arr.length) {
      this.setFromDateObjProxy(dt);
    } else {
      this.setFromTimeProxy(dt.getTime(), tz);
    }
  };

  // Implements most of the native Date object
  timezoneJS.Date.prototype = {
    getDate: function () {
      return this.date;
    },
    getDay: function () {
      return this._day;
    },
    getFullYear: function () {
      return this.year;
    },
    getMonth: function () {
      return this.month;
    },
    getYear: function () {
      return this.year;
    },
    getHours: function () {
      return this.hours;
    },
    getMilliseconds: function () {
      return this.milliseconds;
    },
    getMinutes: function () {
      return this.minutes;
    },
    getSeconds: function () {
      return this.seconds;
    },
    getUTCDate: function () {
      return this.getUTCDateProxy().getUTCDate();
    },
    getUTCDay: function () {
      return this.getUTCDateProxy().getUTCDay();
    },
    getUTCFullYear: function () {
      return this.getUTCDateProxy().getUTCFullYear();
    },
    getUTCHours: function () {
      return this.getUTCDateProxy().getUTCHours();
    },
    getUTCMilliseconds: function () {
      return this.getUTCDateProxy().getUTCMilliseconds();
    },
    getUTCMinutes: function () {
      return this.getUTCDateProxy().getUTCMinutes();
    },
    getUTCMonth: function () {
      return this.getUTCDateProxy().getUTCMonth();
    },
    getUTCSeconds: function () {
      return this.getUTCDateProxy().getUTCSeconds();
    },
    // Time adjusted to user-specified timezone
    getTime: function () {
      return this._timeProxy + this.getTimezoneOffset() * 60 * 1000;
    },
    getTimezone: function () {
      return this.timezone;
    },
    getTimezoneOffset: function () {
      return this.getTimezoneInfo().tzOffset;
    },
    getTimezoneAbbreviation: function () {
      return this.getTimezoneInfo().tzAbbr;
    },
    getTimezoneInfo: function () {
      if (this._useCache) return this._tzInfo;
      var res;
      // If timezone is specified, get the correct timezone info based on the Date given
      if (this.timezone) {
        res =
          this.timezone === "Etc/UTC" || this.timezone === "Etc/GMT"
            ? { tzOffset: 0, tzAbbr: "UTC" }
            : timezoneJS.timezone.getTzInfo(this._timeProxy, this.timezone);
      }
      // If no timezone was specified, use the local browser offset
      else {
        res = { tzOffset: this.getLocalOffset(), tzAbbr: null };
      }
      this._tzInfo = res;
      this._useCache = true;
      return res;
    },
    getUTCDateProxy: function () {
      var dt = new Date(this._timeProxy);
      dt.setUTCMinutes(dt.getUTCMinutes() + this.getTimezoneOffset());
      return dt;
    },
    setDate: function (n) {
      this.setAttribute("date", n);
    },
    setFullYear: function (n) {
      this.setAttribute("year", n);
    },
    setMonth: function (n) {
      this.setAttribute("month", n);
    },
    setYear: function (n) {
      this.setUTCAttribute("year", n);
    },
    setHours: function (n) {
      this.setAttribute("hours", n);
    },
    setMilliseconds: function (n) {
      this.setAttribute("milliseconds", n);
    },
    setMinutes: function (n) {
      this.setAttribute("minutes", n);
    },
    setSeconds: function (n) {
      this.setAttribute("seconds", n);
    },
    setTime: function (n) {
      if (isNaN(n)) {
        throw new Error("Units must be a number.");
      }
      this.setFromTimeProxy(n, this.timezone);
    },
    setUTCDate: function (n) {
      this.setUTCAttribute("date", n);
    },
    setUTCFullYear: function (n) {
      this.setUTCAttribute("year", n);
    },
    setUTCHours: function (n) {
      this.setUTCAttribute("hours", n);
    },
    setUTCMilliseconds: function (n) {
      this.setUTCAttribute("milliseconds", n);
    },
    setUTCMinutes: function (n) {
      this.setUTCAttribute("minutes", n);
    },
    setUTCMonth: function (n) {
      this.setUTCAttribute("month", n);
    },
    setUTCSeconds: function (n) {
      this.setUTCAttribute("seconds", n);
    },
    setFromDateObjProxy: function (dt) {
      this.year = dt.getFullYear();
      this.month = dt.getMonth();
      this.date = dt.getDate();
      this.hours = dt.getHours();
      this.minutes = dt.getMinutes();
      this.seconds = dt.getSeconds();
      this.milliseconds = dt.getMilliseconds();
      this._day = dt.getDay();
      this._dateProxy = dt;
      this._timeProxy = Date.UTC(
        this.year,
        this.month,
        this.date,
        this.hours,
        this.minutes,
        this.seconds,
        this.milliseconds
      );
      this._useCache = false;
    },
    setFromTimeProxy: function (utcMillis, tz) {
      var dt = new Date(utcMillis);
      var tzOffset;
      tzOffset = tz
        ? timezoneJS.timezone.getTzInfo(dt, tz).tzOffset
        : dt.getTimezoneOffset();
      dt.setTime(utcMillis + (dt.getTimezoneOffset() - tzOffset) * 60000);
      this.setFromDateObjProxy(dt);
    },
    setAttribute: function (unit, n) {
      if (isNaN(n)) {
        throw new Error("Units must be a number.");
      }
      var dt = this._dateProxy;
      var meth =
        unit === "year"
          ? "FullYear"
          : unit.substr(0, 1).toUpperCase() + unit.substr(1);
      dt["set" + meth](n);
      this.setFromDateObjProxy(dt);
    },
    setUTCAttribute: function (unit, n) {
      if (isNaN(n)) {
        throw new Error("Units must be a number.");
      }
      var meth =
        unit === "year"
          ? "FullYear"
          : unit.substr(0, 1).toUpperCase() + unit.substr(1);
      var dt = this.getUTCDateProxy();
      dt["setUTC" + meth](n);
      dt.setUTCMinutes(dt.getUTCMinutes() - this.getTimezoneOffset());
      this.setFromTimeProxy(
        dt.getTime() + this.getTimezoneOffset() * 60000,
        this.timezone
      );
    },
    setTimezone: function (tz) {
      var previousOffset = this.getTimezoneInfo().tzOffset;
      this.timezone = tz;
      this._useCache = false;
      // Set UTC minutes offsets by the delta of the two timezones
      this.setUTCMinutes(
        this.getUTCMinutes() - this.getTimezoneInfo().tzOffset + previousOffset
      );
    },
    removeTimezone: function () {
      this.timezone = null;
      this._useCache = false;
    },
    valueOf: function () {
      return this.getTime();
    },
    clone: function () {
      return this.timezone
        ? new timezoneJS.Date(this.getTime(), this.timezone)
        : new timezoneJS.Date(this.getTime());
    },
    toGMTString: function () {
      return this.toString("EEE, dd MMM yyyy HH:mm:ss Z", "Etc/GMT");
    },
    toLocaleString: function () {},
    toLocaleDateString: function () {},
    toLocaleTimeString: function () {},
    toSource: function () {},
    toISOString: function () {
      return this.toString("yyyy-MM-ddTHH:mm:ss.SSS", "Etc/UTC") + "Z";
    },
    toJSON: function () {
      return this.toISOString();
    },
    // Allows different format following ISO8601 format:
    toString: function (format, tz) {
      // Default format is the same as toISOString
      if (!format) format = "yyyy-MM-dd HH:mm:ss";
      var result = format;
      var tzInfo = tz
        ? timezoneJS.timezone.getTzInfo(this.getTime(), tz)
        : this.getTimezoneInfo();
      var _this = this;
      // If timezone is specified, get a clone of the current Date object and modify it
      if (tz) {
        _this = this.clone();
        _this.setTimezone(tz);
      }
      var hours = _this.getHours();
      return (
        result
          // fix the same characters in Month names
          .replace(/a+/g, function () {
            return "k";
          })
          // `y`: year
          .replace(/y+/g, function (token) {
            return _fixWidth(_this.getFullYear(), token.length);
          })
          // `d`: date
          .replace(/d+/g, function (token) {
            return _fixWidth(_this.getDate(), token.length);
          })
          // `m`: minute
          .replace(/m+/g, function (token) {
            return _fixWidth(_this.getMinutes(), token.length);
          })
          // `s`: second
          .replace(/s+/g, function (token) {
            return _fixWidth(_this.getSeconds(), token.length);
          })
          // `S`: millisecond
          .replace(/S+/g, function (token) {
            return _fixWidth(_this.getMilliseconds(), token.length);
          })
          // `M`: month. Note: `MM` will be the numeric representation (e.g February is 02) but `MMM` will be text representation (e.g February is Feb)
          .replace(/M+/g, function (token) {
            var _month = _this.getMonth(),
              _len = token.length;
            if (_len > 3) {
              return timezoneJS.Months[_month];
            } else if (_len > 2) {
              return timezoneJS.Months[_month].substring(0, _len);
            }
            return _fixWidth(_month + 1, _len);
          })
          // `k`: AM/PM
          .replace(/k+/g, function () {
            if (hours >= 12) {
              if (hours > 12) {
                hours -= 12;
              }
              return "PM";
            }
            return "AM";
          })
          // `H`: hour
          .replace(/H+/g, function (token) {
            return _fixWidth(hours, token.length);
          })
          // `E`: day
          .replace(/E+/g, function (token) {
            return DAYS[_this.getDay()].substring(0, token.length);
          })
          // `Z`: timezone abbreviation
          .replace(/Z+/gi, function () {
            return tzInfo.tzAbbr;
          })
      );
    },
    toUTCString: function () {
      return this.toGMTString();
    },
    civilToJulianDayNumber: function (y, m, d) {
      var a;
      // Adjust for zero-based JS-style array
      m++;
      if (m > 12) {
        a = parseInt(m / 12, 10);
        m = m % 12;
        y += a;
      }
      if (m <= 2) {
        y -= 1;
        m += 12;
      }
      a = Math.floor(y / 100);
      var b = 2 - a + Math.floor(a / 4),
        jDt =
          Math.floor(365.25 * (y + 4716)) +
          Math.floor(30.6001 * (m + 1)) +
          d +
          b -
          1524;
      return jDt;
    },
    getLocalOffset: function () {
      return this._dateProxy.getTimezoneOffset();
    },
  };

  timezoneJS.timezone = new (function () {
    var _this = this,
      regionMap = {
        Etc: "etcetera",
        EST: "northamerica",
        MST: "northamerica",
        HST: "northamerica",
        EST5EDT: "northamerica",
        CST6CDT: "northamerica",
        MST7MDT: "northamerica",
        PST8PDT: "northamerica",
        America: "northamerica",
        Pacific: "australasia",
        Atlantic: "europe",
        Africa: "africa",
        Indian: "africa",
        Antarctica: "antarctica",
        Asia: "asia",
        Australia: "australasia",
        Europe: "europe",
        WET: "europe",
        CET: "europe",
        MET: "europe",
        EET: "europe",
      },
      regionExceptions = {
        "Pacific/Honolulu": "northamerica",
        "Atlantic/Bermuda": "northamerica",
        "Atlantic/Cape_Verde": "africa",
        "Atlantic/St_Helena": "africa",
        "Indian/Kerguelen": "antarctica",
        "Indian/Chagos": "asia",
        "Indian/Maldives": "asia",
        "Indian/Christmas": "australasia",
        "Indian/Cocos": "australasia",
        "America/Danmarkshavn": "europe",
        "America/Scoresbysund": "europe",
        "America/Godthab": "europe",
        "America/Thule": "europe",
        "Asia/Yekaterinburg": "europe",
        "Asia/Omsk": "europe",
        "Asia/Novosibirsk": "europe",
        "Asia/Krasnoyarsk": "europe",
        "Asia/Irkutsk": "europe",
        "Asia/Yakutsk": "europe",
        "Asia/Vladivostok": "europe",
        "Asia/Sakhalin": "europe",
        "Asia/Magadan": "europe",
        "Asia/Kamchatka": "europe",
        "Asia/Anadyr": "europe",
        "Africa/Ceuta": "europe",
        "America/Argentina/Buenos_Aires": "southamerica",
        "America/Argentina/Cordoba": "southamerica",
        "America/Argentina/Tucuman": "southamerica",
        "America/Argentina/La_Rioja": "southamerica",
        "America/Argentina/San_Juan": "southamerica",
        "America/Argentina/Jujuy": "southamerica",
        "America/Argentina/Catamarca": "southamerica",
        "America/Argentina/Mendoza": "southamerica",
        "America/Argentina/Rio_Gallegos": "southamerica",
        "America/Argentina/Ushuaia": "southamerica",
        "America/Aruba": "southamerica",
        "America/La_Paz": "southamerica",
        "America/Noronha": "southamerica",
        "America/Belem": "southamerica",
        "America/Fortaleza": "southamerica",
        "America/Recife": "southamerica",
        "America/Araguaina": "southamerica",
        "America/Maceio": "southamerica",
        "America/Bahia": "southamerica",
        "America/Sao_Paulo": "southamerica",
        "America/Campo_Grande": "southamerica",
        "America/Cuiaba": "southamerica",
        "America/Porto_Velho": "southamerica",
        "America/Boa_Vista": "southamerica",
        "America/Manaus": "southamerica",
        "America/Eirunepe": "southamerica",
        "America/Rio_Branco": "southamerica",
        "America/Santiago": "southamerica",
        "Pacific/Easter": "southamerica",
        "America/Bogota": "southamerica",
        "America/Curacao": "southamerica",
        "America/Guayaquil": "southamerica",
        "Pacific/Galapagos": "southamerica",
        "Atlantic/Stanley": "southamerica",
        "America/Cayenne": "southamerica",
        "America/Guyana": "southamerica",
        "America/Asuncion": "southamerica",
        "America/Lima": "southamerica",
        "Atlantic/South_Georgia": "southamerica",
        "America/Paramaribo": "southamerica",
        "America/Port_of_Spain": "southamerica",
        "America/Montevideo": "southamerica",
        "America/Caracas": "southamerica",
      };
    function invalidTZError(t) {
      throw new Error(
        'Timezone "' +
          t +
          '" is either incorrect, or not loaded in the timezone registry.'
      );
    }
    function builtInLoadZoneFile(fileName, opts) {
      var url = _this.zoneFileBasePath + "/" + fileName;
      return !opts || !opts.async
        ? _this.parseZones(_this.transport({ url: url, async: false }))
        : _this.transport({
            async: true,
            url: url,
            success: function (str) {
              if (
                _this.parseZones(str) &&
                typeof opts.callback === "function"
              ) {
                opts.callback();
              }
              return true;
            },
            error: function () {
              throw new Error('Error retrieving "' + url + '" zoneinfo files');
            },
          });
    }
    function getRegionForTimezone(tz) {
      var exc = regionExceptions[tz],
        reg,
        ret;
      if (exc) return exc;
      reg = tz.split("/")[0];
      ret = regionMap[reg];
      // If there's nothing listed in the main regions for this TZ, check the 'backward' links
      if (ret) return ret;
      var link = _this.zones[tz];
      if (typeof link === "string") {
        return getRegionForTimezone(link);
      }
      // Backward-compat file hasn't loaded yet, try looking in there
      if (!_this.loadedZones.backward) {
        // This is for obvious legacy zones (e.g., Iceland) that don't even have a prefix like "America/" that look like normal zones
        _this.loadZoneFile("backward");
        return getRegionForTimezone(tz);
      }
      invalidTZError(tz);
    }
    function parseTimeString(str) {
      var pat = /(\d+)(?::0*(\d*))?(?::0*(\d*))?([wsugz])?$/;
      var hms = str.match(pat);
      hms[1] = parseInt(hms[1], 10);
      hms[2] = hms[2] ? parseInt(hms[2], 10) : 0;
      hms[3] = hms[3] ? parseInt(hms[3], 10) : 0;

      return hms;
    }
    function processZone(z) {
      if (!z[3]) {
        return;
      }
      var yea = parseInt(z[3], 10);
      var mon = 11;
      var dat = 31;
      if (z[4]) {
        mon = SHORT_MONTHS[z[4].substr(0, 3)];
        dat = parseInt(z[5], 10) || 1;
      }
      var string = z[6] ? z[6] : "00:00:00",
        t = parseTimeString(string);
      return [yea, mon, dat, t[1], t[2], t[3]];
    }
    function getZone(dt, tz) {
      var utcMillis = typeof dt === "number" ? dt : new Date(dt).getTime();
      var t = tz;
      var zoneList = _this.zones[t];
      // Follow links to get to an actual zone
      while (typeof zoneList === "string") {
        t = zoneList;
        zoneList = _this.zones[t];
      }
      if (!zoneList) {
        // Backward-compat file hasn't loaded yet, try looking in there
        if (!_this.loadedZones.backward) {
          //This is for backward entries like "America/Fort_Wayne" that
          // getRegionForTimezone *thinks* it has a region file and zone
          // for (e.g., America => 'northamerica'), but in reality it's a
          // legacy zone we need the backward file for.
          _this.loadZoneFile("backward");
          return getZone(dt, tz);
        }
        invalidTZError(t);
      }
      if (zoneList.length === 0) {
        throw new Error('No Zone found for "' + tz + '" on ' + dt);
      }
      //Do backwards lookup since most use cases deal with newer dates.
      for (var i = zoneList.length - 1; i >= 0; i--) {
        var z = zoneList[i];
        if (z[3] && utcMillis > z[3]) break;
      }
      return zoneList[i + 1];
    }
    function getBasicOffset(time) {
      var off = parseTimeString(time),
        adj = time.indexOf("-") === 0 ? -1 : 1;
      off = adj * (((off[1] * 60 + off[2]) * 60 + off[3]) * 1000);
      return off / 60 / 1000;
    }

    //if isUTC is true, date is given in UTC, otherwise it's given
    // in local time (ie. date.getUTC*() returns local time components)
    function getRule(dt, zone, isUTC) {
      var date = typeof dt === "number" ? new Date(dt) : dt;
      var ruleset = zone[1];
      var basicOffset = zone[0];

      //Convert a date to UTC. Depending on the 'type' parameter, the date
      // parameter may be:
      //
      // - `u`, `g`, `z`: already UTC (no adjustment).
      //
      // - `s`: standard time (adjust for time zone offset but not for DST)
      //
      // - `w`: wall clock time (adjust for both time zone and DST offset).
      //
      // DST adjustment is done using the rule given as third argument.
      var convertDateToUTC = function (date, type, rule) {
        var offset = 0;

        if (type === "u" || type === "g" || type === "z") {
          // UTC
          offset = 0;
        } else if (type === "s") {
          // Standard Time
          offset = basicOffset;
        } else if (type === "w" || !type) {
          // Wall Clock Time
          offset = getAdjustedOffset(basicOffset, rule);
        } else {
          throw "unknown type " + type;
        }
        offset *= 60 * 1000; // to millis

        return new Date(date.getTime() + offset);
      };

      //Step 1:  Find applicable rules for this year.
      //
      //Step 2:  Sort the rules by effective date.
      //
      //Step 3:  Check requested date to see if a rule has yet taken effect this year.  If not,
      //
      //Step 4:  Get the rules for the previous year.  If there isn't an applicable rule for last year, then
      // there probably is no current time offset since they seem to explicitly turn off the offset
      // when someone stops observing DST.
      //
      // FIXME if this is not the case and we'll walk all the way back (ugh).
      //
      //Step 5:  Sort the rules by effective date.
      //Step 6:  Apply the most recent rule before the current time.
      var convertRuleToExactDateAndTime = function (yearAndRule, prevRule) {
        var year = yearAndRule[0],
          rule = yearAndRule[1];
        // Assume that the rule applies to the year of the given date.

        var hms = rule[5];
        var effectiveDate;

        if (!EXACT_DATE_TIME[year]) EXACT_DATE_TIME[year] = {};

        // Result for given parameters is already stored
        if (EXACT_DATE_TIME[year][rule])
          effectiveDate = EXACT_DATE_TIME[year][rule];
        else {
          //If we have a specific date, use that!
          if (!isNaN(rule[4])) {
            effectiveDate = new Date(
              Date.UTC(
                year,
                SHORT_MONTHS[rule[3]],
                rule[4],
                hms[1],
                hms[2],
                hms[3],
                0
              )
            );
          }
          //Let's hunt for the date.
          else {
            var targetDay, operator;
            //Example: `lastThu`
            if (rule[4].substr(0, 4) === "last") {
              // Start at the last day of the month and work backward.
              effectiveDate = new Date(
                Date.UTC(
                  year,
                  SHORT_MONTHS[rule[3]] + 1,
                  1,
                  hms[1] - 24,
                  hms[2],
                  hms[3],
                  0
                )
              );
              targetDay = SHORT_DAYS[rule[4].substr(4, 3)];
              operator = "<=";
            }
            //Example: `Sun>=15`
            else {
              //Start at the specified date.
              effectiveDate = new Date(
                Date.UTC(
                  year,
                  SHORT_MONTHS[rule[3]],
                  rule[4].substr(5),
                  hms[1],
                  hms[2],
                  hms[3],
                  0
                )
              );
              targetDay = SHORT_DAYS[rule[4].substr(0, 3)];
              operator = rule[4].substr(3, 2);
            }
            var ourDay = effectiveDate.getUTCDay();
            //Go forwards.
            if (operator === ">=") {
              effectiveDate.setUTCDate(
                effectiveDate.getUTCDate() +
                  (targetDay - ourDay + (targetDay < ourDay ? 7 : 0))
              );
            }
            //Go backwards.  Looking for the last of a certain day, or operator is "<=" (less likely).
            else {
              effectiveDate.setUTCDate(
                effectiveDate.getUTCDate() +
                  (targetDay - ourDay - (targetDay > ourDay ? 7 : 0))
              );
            }
          }
          EXACT_DATE_TIME[year][rule] = effectiveDate;
        }

        //If previous rule is given, correct for the fact that the starting time of the current
        // rule may be specified in local time.
        if (prevRule) {
          effectiveDate = convertDateToUTC(effectiveDate, hms[4], prevRule);
        }
        return effectiveDate;
      };

      var findApplicableRules = function (year, ruleset) {
        var applicableRules = [];
        for (var i = 0; ruleset && i < ruleset.length; i++) {
          //Exclude future rules.
          if (
            ruleset[i][0] <= year &&
            // Date is in a set range.
            (ruleset[i][1] >= year ||
              // Date is in an "only" year.
              (ruleset[i][0] === year && ruleset[i][1] === "only") ||
              //We're in a range from the start year to infinity.
              ruleset[i][1] === "max")
          ) {
            //It's completely okay to have any number of matches here.
            // Normally we should only see two, but that doesn't preclude other numbers of matches.
            // These matches are applicable to this year.
            applicableRules.push([year, ruleset[i]]);
          }
        }
        return applicableRules;
      };

      var compareDates = function (a, b, prev) {
        var year, rule;
        if (a.constructor !== Date) {
          year = a[0];
          rule = a[1];
          a =
            !prev && EXACT_DATE_TIME[year] && EXACT_DATE_TIME[year][rule]
              ? EXACT_DATE_TIME[year][rule]
              : convertRuleToExactDateAndTime(a, prev);
        } else if (prev) {
          a = convertDateToUTC(a, isUTC ? "u" : "w", prev);
        }
        if (b.constructor !== Date) {
          year = b[0];
          rule = b[1];
          b =
            !prev && EXACT_DATE_TIME[year] && EXACT_DATE_TIME[year][rule]
              ? EXACT_DATE_TIME[year][rule]
              : convertRuleToExactDateAndTime(b, prev);
        } else if (prev) {
          b = convertDateToUTC(b, isUTC ? "u" : "w", prev);
        }
        a = Number(a);
        b = Number(b);
        return a - b;
      };

      var year = date.getUTCFullYear();
      var applicableRules;

      applicableRules = findApplicableRules(year, _this.rules[ruleset]);
      applicableRules.push(date);
      //While sorting, the time zone in which the rule starting time is specified
      // is ignored. This is ok as long as the timespan between two DST changes is
      // larger than the DST offset, which is probably always true.
      // As the given date may indeed be close to a DST change, it may get sorted
      // to a wrong position (off by one), which is corrected below.
      applicableRules.sort(compareDates);

      //If there are not enough past DST rules...
      if (applicableRules.indexOf(date) < 2) {
        applicableRules = applicableRules.concat(
          findApplicableRules(year - 1, _this.rules[ruleset])
        );
        applicableRules.sort(compareDates);
      }
      var pinpoint = applicableRules.indexOf(date);
      if (
        pinpoint > 1 &&
        compareDates(
          date,
          applicableRules[pinpoint - 1],
          applicableRules[pinpoint - 2][1]
        ) < 0
      ) {
        //The previous rule does not really apply, take the one before that.
        return applicableRules[pinpoint - 2][1];
      } else if (
        pinpoint > 0 &&
        pinpoint < applicableRules.length - 1 &&
        compareDates(
          date,
          applicableRules[pinpoint + 1],
          applicableRules[pinpoint - 1][1]
        ) > 0
      ) {
        //The next rule does already apply, take that one.
        return applicableRules[pinpoint + 1][1];
      } else if (pinpoint === 0) {
        //No applicable rule found in this and in previous year.
        return null;
      }
      return applicableRules[pinpoint - 1][1];
    }
    function getAdjustedOffset(off, rule) {
      return -Math.ceil(rule[6] - off);
    }
    function getAbbreviation(zone, rule) {
      var res;
      var base = zone[2];
      if (base.indexOf("%s") > -1) {
        var repl;
        if (rule) {
          repl = rule[7] === "-" ? "" : rule[7];
        }
        //FIXME: Right now just falling back to Standard --
        // apparently ought to use the last valid rule,
        // although in practice that always ought to be Standard
        else {
          repl = "S";
        }
        res = base.replace("%s", repl);
      } else if (base.indexOf("/") > -1) {
        //Chose one of two alternative strings.
        res = base.split("/", 2)[rule[6] ? 1 : 0];
      } else {
        res = base;
      }
      return res;
    }

    this.zoneFileBasePath;
    this.zoneFiles = [
      "africa",
      "antarctica",
      "asia",
      "australasia",
      "backward",
      "etcetera",
      "europe",
      "northamerica",
      "pacificnew",
      "southamerica",
    ];
    this.loadingSchemes = {
      PRELOAD_ALL: "preloadAll",
      LAZY_LOAD: "lazyLoad",
      MANUAL_LOAD: "manualLoad",
    };
    this.loadingScheme = this.loadingSchemes.LAZY_LOAD;
    this.loadedZones = {};
    this.zones = {};
    this.rules = {};

    this.init = function (o) {
      var opts = { async: true },
        def = (this.defaultZoneFile =
          this.loadingScheme === this.loadingSchemes.PRELOAD_ALL
            ? this.zoneFiles
            : "northamerica"),
        done = 0,
        callbackFn;
      //Override default with any passed-in opts
      for (var p in o) {
        opts[p] = o[p];
      }
      if (typeof def === "string") {
        return this.loadZoneFile(def, opts);
      }
      //Wraps callback function in another one that makes
      // sure all files have been loaded.
      callbackFn = opts.callback;
      opts.callback = function () {
        done++;
        done === def.length && typeof callbackFn === "function" && callbackFn();
      };
      for (var i = 0; i < def.length; i++) {
        this.loadZoneFile(def[i], opts);
      }
    };

    //Get the zone files via XHR -- if the sync flag
    // is set to true, it's being called by the lazy-loading
    // mechanism, so the result needs to be returned inline.
    this.loadZoneFile = function (fileName, opts) {
      if (typeof this.zoneFileBasePath === "undefined") {
        throw new Error(
          "Please define a base path to your zone file directory -- timezoneJS.timezone.zoneFileBasePath."
        );
      }
      //Ignore already loaded zones.
      if (this.loadedZones[fileName]) {
        return;
      }
      this.loadedZones[fileName] = true;
      return builtInLoadZoneFile(fileName, opts);
    };
    this.loadZoneJSONData = function (url, sync) {
      var processData = function (data) {
        data = eval("(" + data + ")");
        for (var z in data.zones) {
          _this.zones[z] = data.zones[z];
        }
        for (var r in data.rules) {
          _this.rules[r] = data.rules[r];
        }
      };
      return sync
        ? processData(_this.transport({ url: url, async: false }))
        : _this.transport({ url: url, success: processData });
    };
    this.loadZoneDataFromObject = function (data) {
      if (!data) {
        return;
      }
      for (var z in data.zones) {
        _this.zones[z] = data.zones[z];
      }
      for (var r in data.rules) {
        _this.rules[r] = data.rules[r];
      }
    };
    this.getAllZones = function () {
      var arr = [];
      for (var z in this.zones) {
        arr.push(z);
      }
      return arr.sort();
    };
    this.parseZones = function (str) {
      var lines = str.split("\n"),
        arr = [],
        chunk = "",
        l,
        zone = null,
        rule = null;
      for (var i = 0; i < lines.length; i++) {
        l = lines[i];
        if (l.match(/^\s/)) {
          l = "Zone " + zone + l;
        }
        l = l.split("#")[0];
        if (l.length > 3) {
          arr = l.split(/\s+/);
          chunk = arr.shift();
          //Ignore Leap.
          switch (chunk) {
            case "Zone":
              zone = arr.shift();
              if (!_this.zones[zone]) {
                _this.zones[zone] = [];
              }
              if (arr.length < 3) break;
              //Process zone right here and replace 3rd element with the processed array.
              arr.splice(3, arr.length, processZone(arr));
              if (arr[3]) arr[3] = Date.UTC.apply(null, arr[3]);
              arr[0] = -getBasicOffset(arr[0]);
              _this.zones[zone].push(arr);
              break;
            case "Rule":
              rule = arr.shift();
              if (!_this.rules[rule]) {
                _this.rules[rule] = [];
              }
              //Parse int FROM year and TO year
              arr[0] = parseInt(arr[0], 10);
              arr[1] = parseInt(arr[1], 10) || arr[1];
              //Parse time string AT
              arr[5] = parseTimeString(arr[5]);
              //Parse offset SAVE
              arr[6] = getBasicOffset(arr[6]);
              _this.rules[rule].push(arr);
              break;
            case "Link":
              //No zones for these should already exist.
              if (_this.zones[arr[1]]) {
                throw new Error(
                  "Error with Link " +
                    arr[1] +
                    ". Cannot create link of a preexisted zone."
                );
              }
              //Create the link.
              _this.zones[arr[1]] = arr[0];
              break;
          }
        }
      }
      return true;
    };
    //Expose transport mechanism and allow overwrite.
    this.transport = _transport;
    this.getTzInfo = function (dt, tz, isUTC) {
      //Lazy-load any zones not yet loaded.
      if (this.loadingScheme === this.loadingSchemes.LAZY_LOAD) {
        //Get the correct region for the zone.
        var zoneFile = getRegionForTimezone(tz);
        if (!zoneFile) {
          throw new Error("Not a valid timezone ID.");
        }
        if (!this.loadedZones[zoneFile]) {
          //Get the file and parse it -- use synchronous XHR.
          this.loadZoneFile(zoneFile);
        }
      }
      var z = getZone(dt, tz);
      var off = z[0];
      //See if the offset needs adjustment.
      var rule = getRule(dt, z, isUTC);
      if (rule) {
        off = getAdjustedOffset(off, rule);
      }
      var abbr = getAbbreviation(z, rule);
      return { tzOffset: off, tzAbbr: abbr };
    };
  })();
}.call(this));