(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.jiboDataUtils = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const LocationUtils_1 = require("./LocationUtils");
const Timezone_1 = require("./Timezone");
const jibo_log_1 = require("jibo-log");
let log = new jibo_log_1.Log('Location');
function initLog(parentLog) {
    log = parentLog.createChild('Location');
}
exports.initLog = initLog;
const MILES_TO_RADIANS = 1 / 3959;
const BOUNDS_RADIUS = 100 * MILES_TO_RADIANS;
const RADS_TO_DEGREES = 180 / Math.PI;
const DEGREES_TO_RADS = Math.PI / 180;
function moveLatLong(inLat, inLng, distRadians, angleRadians) {
    inLat *= DEGREES_TO_RADS;
    inLng *= DEGREES_TO_RADS;
    let PI = Math.PI;
    let lat = Math.asin(Math.sin(inLat) * Math.cos(distRadians) + Math.cos(inLat) * Math.sin(distRadians) * Math.cos(angleRadians));
    let lng;
    if (Math.cos(lat) === 0) {
        lng = inLng;
    }
    else {
        lng = (inLng - Math.asin(Math.sin(angleRadians) * Math.sin(distRadians) / Math.cos(lat)) + PI) % (2 * PI) - PI;
    }
    return { lat: lat * RADS_TO_DEGREES, lng: lng * RADS_TO_DEGREES };
}
function toTitleCase(str) {
    return str.replace(/\w\S*/g, function (txt) { return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase(); });
}
function areStringsEqual(strA, strB) {
    if (strA && !strB) {
        return false;
    }
    if (strB && !strA) {
        return false;
    }
    if (!strA && !strB) {
        return true;
    }
    return strA.toLowerCase() === strB.toLowerCase();
}
let JIBO_HOME = null;
class Location {
    static create(city, state, country) {
        if (city === 'null') {
            city = null;
        }
        if (state === 'null') {
            state = null;
        }
        if (country === 'null') {
            country = null;
        }
        if (!city && !state && !country) {
            return JIBO_HOME;
        }
        return new Location(city, state, country);
    }
    constructor(city, state, country) {
        if (city === 'null') {
            city = null;
        }
        if (state === 'null') {
            state = null;
        }
        if (country === 'null') {
            country = null;
        }
        this.city = city;
        this.stateAbbr = state;
        this.state = null;
        this.country = country;
        this.countryCode = null;
        if (!city && state) {
            this.city = LocationUtils_1.LocationUtils.getUSStateCapital(state);
        }
        this.needsTimezone = false;
        this.timezone = null;
        this.lat = null;
        this.lng = null;
        this.latLongBounds = null;
        this.calculatedRegions = null;
    }
    static get jiboHome() {
        return JIBO_HOME;
    }
    get isLocal() {
        return this.equals(JIBO_HOME);
    }
    fetch(callback, skipWA = false) {
        if (this.lat !== null && this.lng !== null) {
            let ll = { lat: this.lat, lng: this.lng };
            if (this.needsTimezone && !this.timezone) {
                this.timezone = new Timezone_1.default();
                this.timezone.fetch(ll, () => {
                    callback(null, ll);
                });
            }
            else {
                callback(null, ll);
            }
        }
        else {
            if (!skipWA && !this.city && !this.stateAbbr && this.country) {
                LocationUtils_1.LocationUtils.getCountryCapital(this.country)
                    .then((data) => {
                    this.city = data.city;
                    this.state = data.state;
                    this.country = data.country || this.country;
                    log.debug('Got capital from WA');
                    this.fetch(callback);
                })
                    .catch((e) => {
                    if (e !== LocationUtils_1.LocationUtils.NO_VALID_RESULTS_FROM_WA) {
                        log.warn('Error looking up capital', e);
                    }
                    else {
                        log.debug('WA did not get us a capital');
                    }
                    this.fetch(callback, true);
                });
                return;
            }
            let city = this.city;
            let address = [city, this.stateAbbr, this.country]
                .filter((n) => { return !!n; })
                .join(', ');
            let opts;
            let bounds = JIBO_HOME.getLatLongBounds();
            if (bounds) {
                opts = { bounds: `${bounds.south.toFixed(12)},${bounds.west.toFixed(12)}|${bounds.north.toFixed(12)},${bounds.east.toFixed(12)}` };
            }
            LocationUtils_1.LocationUtils.geocode(address, (err, data) => {
                if (err) {
                    log.warn('Error when geocoding: ', err);
                    callback(err, null);
                    return;
                }
                if (!data || !data.results || !data.results.length || !data.results[0].geometry ||
                    !data.results[0].geometry.location) {
                    let message = 'Bad geocode results: ';
                    const jsonData = JSON.stringify(data);
                    if (!data) {
                        message += 'no data';
                    }
                    else if (!data.results) {
                        message += 'data does not have results - ' + jsonData;
                    }
                    else if (!data.results.length) {
                        message += 'results is empty - ' + jsonData;
                    }
                    else if (!data.results[0].geometry) {
                        message += 'first result has no geometry - ' + jsonData;
                    }
                    else if (!data.results[0].geometry.location) {
                        message += 'first result has no location - ' + jsonData;
                    }
                    log.warn(`On search for ${address}`, message);
                    callback(message, null);
                    return;
                }
                else {
                    let result = null;
                    for (let i = 0; i < data.results.length; ++i) {
                        let types = data.results[i].types;
                        if (types.indexOf('political') >= 0 &&
                            (!this.city || types.indexOf('locality') >= 0 ||
                                types.indexOf('sublocality') >= 0)) {
                            result = data.results[i];
                            break;
                        }
                    }
                    if (!result && this.city) {
                        for (let i = 0; i < data.results.length; ++i) {
                            let types = data.results[i].address_components[0].types;
                            if (types.indexOf('political') >= 0 &&
                                (types.indexOf('administrative_area_level_1') >= 0 ||
                                    types.indexOf('administrative_area_level_2') >= 0)) {
                                result = data.results[i];
                                break;
                            }
                        }
                    }
                    if (!result) {
                        log.warn('No valid location found: ', data);
                        callback('no valid location found - ' + JSON.stringify(data), null);
                        return;
                    }
                    let location = result.geometry.location;
                    this.lat = location.lat;
                    this.lng = location.lng;
                    let components = result.address_components;
                    let foundCity = null;
                    let foundState = null;
                    let foundStateAbbr = null;
                    let foundCountry = null;
                    let foundCountryCode = null;
                    for (let i = components.length - 1; i >= 0; --i) {
                        let comp = components[i];
                        if (comp.types.indexOf('locality') >= 0 ||
                            comp.types.indexOf('sublocality') >= 0) {
                            foundCity = comp.long_name;
                        }
                        if (comp.types.indexOf('administrative_area_level_2') >= 0 && !foundCity) {
                            foundCity = comp.long_name;
                        }
                        if (comp.types.indexOf('administrative_area_level_1') >= 0) {
                            foundState = comp.long_name;
                            foundStateAbbr = comp.short_name.toLowerCase();
                        }
                        if (comp.types.indexOf('country') >= 0) {
                            foundCountryCode = comp.short_name;
                            if (foundCountryCode === 'US') {
                                foundCountry = 'usa';
                            }
                            else {
                                foundCountry = comp.long_name.toLowerCase();
                            }
                        }
                    }
                    this.city = foundCity;
                    this.stateAbbr = foundStateAbbr;
                    if (foundCountryCode === 'US') {
                        this.state = LocationUtils_1.LocationUtils.getFullState(this.stateAbbr) || foundState;
                    }
                    else {
                        this.state = foundState;
                    }
                    if (foundCountry) {
                        this.country = foundCountry;
                        this.countryCode = foundCountryCode;
                    }
                    if (this.needsTimezone && !this.timezone) {
                        this.timezone = new Timezone_1.default();
                        this.timezone.fetch(location, () => {
                            callback(null, location);
                        });
                    }
                    else {
                        callback(null, location);
                    }
                }
            }, opts);
        }
    }
    isInRegion(regions) {
        if (!this.calculatedRegions) {
            this.calculatedRegions = this.calculateRegions();
        }
        if (typeof regions === 'string') {
            return this.calculatedRegions.indexOf(regions) > -1;
        }
        for (let i = 0, length = regions.length; i < length; ++i) {
            if (this.calculatedRegions.indexOf(regions[i]) > -1) {
                return true;
            }
        }
        return false;
    }
    equals(loc) {
        if (this === loc) {
            return true;
        }
        return (areStringsEqual(this.city, loc.city) &&
            areStringsEqual(this.stateAbbr, loc.stateAbbr) &&
            areStringsEqual(this.country, loc.country));
    }
    getStandardName() {
        let rtn = '';
        if (this.equals(JIBO_HOME)) {
            return rtn;
        }
        if (this.city) {
            rtn += this.city;
        }
        if (this.state && (!this.city || this.countryCode === JIBO_HOME.countryCode || this.countryCode === 'US')) {
            if (rtn.length) {
                rtn += ' ';
            }
            rtn += this.state;
        }
        if (this.country && (this.countryCode !== JIBO_HOME.countryCode && this.countryCode !== 'US')) {
            if (rtn.length) {
                rtn += ' ';
            }
            if (this.countryCode === 'US') {
                rtn += 'U.S.A.';
            }
            else {
                rtn += this.country;
            }
        }
        return rtn;
    }
    prefixIn() {
        if (this.equals(JIBO_HOME)) {
            return '';
        }
        return 'In ' + this.getStandardName();
    }
    toString() {
        let rtn = '';
        if (this.city) {
            rtn += toTitleCase(this.city);
        }
        if (this.state && (!this.city || this.countryCode === JIBO_HOME.countryCode)) {
            if (rtn.length) {
                rtn += ', ';
            }
            rtn += this.countryCode === 'US' && this.stateAbbr ? this.stateAbbr.toUpperCase() : this.state;
        }
        if (this.country && this.countryCode !== JIBO_HOME.countryCode) {
            if (rtn.length) {
                rtn += ', ';
            }
            if (this.countryCode === 'US') {
                rtn += 'USA';
            }
            else {
                rtn += toTitleCase(this.country);
            }
        }
        return rtn;
    }
    toLog() {
        return `[Location: ${this.toString()}]`;
    }
    toJSON() {
        return {
            __type: 'Location',
            city: this.city,
            state: this.state,
            stateAbbr: this.stateAbbr,
            country: this.country,
            countryCode: this.countryCode,
            lat: this.lat,
            lng: this.lng,
            timezone: this.timezone ? this.timezone.toJSON() : null
        };
    }
    getLatLongBounds() {
        if (this.latLongBounds) {
            return this.latLongBounds;
        }
        if (this.lat === null || this.lng === null) {
            return null;
        }
        this.latLongBounds = { north: 0, east: 0, west: 0, south: 0 };
        let tempLL = moveLatLong(this.lat, this.lng, BOUNDS_RADIUS, 0);
        this.latLongBounds.north = tempLL.lat;
        tempLL = moveLatLong(this.lat, this.lng, BOUNDS_RADIUS, Math.PI / 2);
        this.latLongBounds.west = tempLL.lng;
        tempLL = moveLatLong(this.lat, this.lng, BOUNDS_RADIUS, Math.PI);
        this.latLongBounds.south = tempLL.lat;
        tempLL = moveLatLong(this.lat, this.lng, BOUNDS_RADIUS, Math.PI * 1.5);
        this.latLongBounds.east = tempLL.lng;
        return this.latLongBounds;
    }
    calculateRegions() {
        const output = [];
        if (this.countryCode) {
            output.push(this.countryCode.toUpperCase());
            if (this.stateAbbr) {
                output.push(`${this.countryCode.toUpperCase()}-${this.stateAbbr.toUpperCase()}`);
            }
        }
        return output;
    }
}
exports.default = Location;
JIBO_HOME = new Location();
JIBO_HOME.city = 'boston';
JIBO_HOME.stateAbbr = 'ma';
JIBO_HOME.state = 'Massachusetts';
JIBO_HOME.country = 'usa';
JIBO_HOME.countryCode = 'US';
JIBO_HOME.lat = 42.313352;
JIBO_HOME.lng = -71.1273681;
JIBO_HOME.timezone = new Timezone_1.default({
    offsetUTC: -18000000,
    name: "Eastern Standard Time",
    id: "America/New_York",
    __type: "Timezone"
});
function setHome(home) {
    JIBO_HOME = home;
}
exports.setHome = setHome;

},{"./LocationUtils":2,"./Timezone":3,"jibo-log":undefined}],2:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const axios_1 = require("axios");
const crypto = require("crypto");
const querystring = require("querystring");
const URLSafeBase64 = require("urlsafe-base64");
let GOOGLE_API = null;
let WOLFRAM_API = null;
const US_STATES = {
    al: { name: "Alabama", capital: "Montgomery" },
    ak: { name: "Alaska", capital: "Juneau" },
    az: { name: "Arizona", capital: "Phoenix" },
    ar: { name: "Arkansas", capital: "Little Rock" },
    ca: { name: "California", capital: "Sacramento" },
    co: { name: "Colorado", capital: "Denver" },
    ct: { name: "Connecticut", capital: "Hartford" },
    de: { name: "Delaware", capital: "Dover" },
    fl: { name: "Florida", capital: "Tallahassee" },
    ga: { name: "Georgia", capital: "Atlanta" },
    hi: { name: "Hawaii", capital: "Honolulu" },
    id: { name: "Idaho", capital: "Boise" },
    il: { name: "Illinois", capital: "Springfield" },
    in: { name: "Indiana", capital: "Indianapolis" },
    ia: { name: "Iowa", capital: "Des Moines" },
    ka: { name: "Kansas", capital: "Topeka" },
    ky: { name: "Kentucky", capital: "Frankfort" },
    la: { name: "Louisiana", capital: "Baton Rouge" },
    me: { name: "Maine", capital: "Augusta" },
    md: { name: "Maryland", capital: "Annapolis" },
    ma: { name: "Massachusetts", capital: "Boston" },
    mi: { name: "Michigan", capital: "Lansing" },
    mn: { name: "Minnesota", capital: "Saint Paul" },
    ms: { name: "Mississippi", capital: "Jackson" },
    mo: { name: "Missouri", capital: "Jefferson City" },
    mt: { name: "Montana", capital: "Helena" },
    ne: { name: "Nebraska", capital: "Lincoln" },
    nv: { name: "Nevada", capital: "Carson City" },
    nh: { name: "New Hampshire", capital: "Concord" },
    nj: { name: "New Jersey", capital: "Trenton" },
    nm: { name: "New Mexico", capital: "Santa Fe" },
    ny: { name: "New York", capital: "Albany" },
    nc: { name: "North Carolina", capital: "Raleigh" },
    nd: { name: "North Dakota", capital: "Bismarck" },
    oh: { name: "Ohio", capital: "Columbus" },
    ok: { name: "Oklahoma", capital: "Oklahoma City" },
    or: { name: "Oregon", capital: "Salem" },
    pa: { name: "Pennsylvania", capital: "Harrisburg" },
    ri: { name: "Rhode Island", capital: "Providence" },
    sc: { name: "South Carolina", capital: "Columbia" },
    sd: { name: "South Dakota", capital: "Pierre" },
    tn: { name: "Tennessee", capital: "Nashville" },
    tx: { name: "Texas", capital: "Austin" },
    ut: { name: "Utah", capital: "Salt Lake City" },
    vt: { name: "Vermont", capital: "Montpelier" },
    va: { name: "Virginia", capital: "Richmond" },
    wa: { name: "Washington", capital: "Olympia" },
    wv: { name: "West Virginia", capital: "Charleston" },
    wi: { name: "Wisconsin", capital: "Madison" },
    wy: { name: "Wyoming", capital: "Cheyenne" },
    as: { name: "American Samoa", capital: "Pago Pago" },
    gu: { name: "Guam", capital: "Hagåtña" },
    pr: { name: "Puerto Rico", capital: "San Juan" },
    vi: { name: "U.S. Virgin Islands", capital: "Charlotte Amalie" },
    fm: { name: "Federated States of Micronesia", capital: "Palikir" },
    mh: { name: "Marshall Islands", capital: "Majuro" },
    pw: { name: "Palau", capital: "Ngerulmud" }
};
class LocationUtils {
    static setCapitalLookupKey(key) {
        WOLFRAM_API = key;
    }
    static setLocationLookupKey(key) {
        GOOGLE_API = key;
    }
    static getFullState(abbreviation) {
        if (!US_STATES[abbreviation]) {
            return "";
        }
        return US_STATES[abbreviation].name;
    }
    static getUSStateCapital(abbreviation) {
        if (!US_STATES[abbreviation]) {
            return "";
        }
        return US_STATES[abbreviation].capital;
    }
    static getCountryCapital(country) {
        const qs = {
            input: country + ' capital',
            appid: WOLFRAM_API,
            output: "JSON",
            podtitle: "Result",
            scantimeout: 0.5
        };
        let url = 'http://api.wolframalpha.com/v2/query?' + querystring.stringify(qs);
        return axios_1.default.get(url, { timeout: 8000 })
            .then(response => {
            let results = response.data;
            if (!results) {
                throw new Error(LocationUtils.NO_RESULT_FROM_WA);
            }
            if (typeof results === 'string') {
                results = JSON.parse(results);
            }
            let queryResult = results.queryresult;
            if (queryResult && queryResult.success && queryResult.pods) {
                if (queryResult.pods[0] &&
                    queryResult.pods[0].subpods.length > 0 &&
                    queryResult.pods[0].title === "Result") {
                    const result = queryResult.pods[0].subpods[0].plaintext.split(',');
                    let output = {
                        city: result[0].trim()
                    };
                    if (result.length > 1) {
                        output.country = result[result.length - 1].trim();
                    }
                    if (result.length > 2) {
                        output.state = result[result.length - 2].trim();
                    }
                    return output;
                }
            }
            throw new Error(LocationUtils.NO_VALID_RESULTS_FROM_WA);
        });
    }
    static geocode(loc, callback, opts) {
        let endpoint = "/maps/api/geocode/json?";
        let options = Object.assign({ sensor: false, address: loc, client: "gme-jiboinc" }, opts || {});
        options["signature"] = LocationUtils.generateGoogleSignature(GOOGLE_API, endpoint + querystring.stringify(options));
        let url = "https://maps.googleapis.com" + endpoint + querystring.stringify(options);
        axios_1.default.get(url)
            .then(resp => {
            let result;
            try {
                if (typeof resp.data === 'string') {
                    result = JSON.parse(resp.data);
                }
                else {
                    result = resp.data;
                }
            }
            catch (err) {
                callback(err, null);
                return;
            }
            callback(null, result);
        })
            .catch(err => callback(err, null));
    }
    static generateGoogleSignature(key, req) {
        let privateKeyInBuffer = URLSafeBase64.decode(key);
        let hashInABuffer = crypto.createHmac('sha1', privateKeyInBuffer).update(req).digest();
        let hashEncodedWebSafe = URLSafeBase64.encode(hashInABuffer);
        return hashEncodedWebSafe;
    }
}
LocationUtils.NO_RESULT_FROM_WA = 'No Result';
LocationUtils.NO_VALID_RESULTS_FROM_WA = 'No Valid Results';
exports.LocationUtils = LocationUtils;

},{"axios":undefined,"crypto":undefined,"querystring":undefined,"urlsafe-base64":undefined}],3:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const axios_1 = require("axios");
const querystring = require("querystring");
const crypto = require("crypto");
const URLSafeBase64 = require("urlsafe-base64");
exports.isoStringParser = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(([+-])(\d\d):(\d\d)|Z)$/;
let GOOGLE_API = null;
function pad(input, length) {
    if (typeof input === 'number') {
        input = input.toString();
    }
    while (input.length < length) {
        input = '0' + input;
    }
    return input;
}
class Timezone {
    static setLocationLookupKey(key) {
        GOOGLE_API = key;
    }
    static fromISOString(iso) {
        const rtn = new Timezone();
        if (iso && exports.isoStringParser.test(iso)) {
            const [, fullTZ, sign, hour, minute] = iso.match(exports.isoStringParser);
            if (fullTZ !== 'Z') {
                rtn.offsetUTC = (parseInt(hour) * 60 + parseInt(minute)) * 60 * 1000 * (sign === '-' ? -1 : 1);
            }
        }
        return rtn;
    }
    constructor(serializedJSON) {
        this.offsetUTC = 0;
        this.name = "Unknown";
        this.id = "Unknown";
        if (serializedJSON && serializedJSON.__type === 'Timezone') {
            this.offsetUTC = serializedJSON.offsetUTC;
            this.name = serializedJSON.name;
            this.id = serializedJSON.id;
        }
    }
    fetch(location, callback) {
        let timeNow = Math.floor(Date.now() / 1000);
        if (GOOGLE_API === null) {
            callback('No Google API Key present', null);
        }
        let endpoint = '/maps/api/timezone/json?';
        let options = Object.assign({ timestamp: timeNow, location: `${location.lat},${location.lng}`, client: 'gme-jiboinc' });
        options["signature"] = this.generateGoogleSignature(GOOGLE_API, endpoint + querystring.stringify(options));
        let url = "https://maps.googleapis.com" + endpoint + querystring.stringify(options);
        axios_1.default.get(url)
            .then(response => {
            let results = response.data;
            if (typeof results === 'string') {
                results = JSON.parse(results);
            }
            this.offsetUTC = (results.rawOffset + results.dstOffset) * 1000;
            this.name = results.timeZoneName;
            this.id = results.timeZoneId;
            callback(null, this);
        })
            .catch(err => callback(err, null));
    }
    toISOString() {
        const offsetMS = this.offsetUTC;
        const hours = Math.floor(Math.abs(offsetMS / 1000 / 60 / 60));
        const minutes = Math.floor(Math.abs(offsetMS / 1000 / 60 % 60));
        return `${offsetMS < 0 ? '-' : '+'}${pad(hours, 2)}:${pad(minutes, 2)}`;
    }
    toJSON() {
        return {
            __type: 'Timezone',
            offsetUTC: this.offsetUTC,
            name: this.name,
            id: this.id
        };
    }
    generateGoogleSignature(key, req) {
        let privateKeyInBuffer = URLSafeBase64.decode(key);
        let hashInABuffer = crypto.createHmac('sha1', privateKeyInBuffer).update(req).digest();
        let hashEncodedWebSafe = URLSafeBase64.encode(hashInABuffer);
        return hashEncodedWebSafe;
    }
}
exports.default = Timezone;

},{"axios":undefined,"crypto":undefined,"querystring":undefined,"urlsafe-base64":undefined}],4:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Timezone_1 = require("../location/Timezone");
const DateTimeUtils_1 = require("./DateTimeUtils");
const relativeDayParser = /^(-?\d+)(d|wd|w|m|y)/i;
const dateParser = /^(\d+)$/;
const monthDateParser = /^(\d?\d)[\/-](\d?\d)$/;
const fullDateParser = /^(\d\d)\/(\d\d)\/(\d\d\d\d)$/;
const dayOfWeekParser = new RegExp('^(' + DateTimeUtils_1.default.DAYS_OF_WEEK.join('|') + ')(_[-+]?\\dw)?$', 'i');
const pastDOWParser = /^_([-+]?\d+)w$/;
const monthNameParser = new RegExp('^(' + DateTimeUtils_1.default.MONTHS.join('|') + ')$', 'i');
const yearParser = /^(\d{4})$/;
const DAY_IN_MS = 24 * 60 * 60 * 1000;
const HOUR_IN_MS = 60 * 60 * 1000;
const timeParser = /(\d+):(\d\d)(AM|PM)*/;
const relativeTimeParser = /^(-?)(\d+)h(\d+)m(\d+)s$/;
function pad(input, length) {
    if (typeof input === 'number') {
        input = input.toString();
    }
    while (input.length < length) {
        input = '0' + input;
    }
    return input;
}
var timePeriods;
(function (timePeriods) {
    timePeriods["YEAR"] = "year";
    timePeriods["MONTH"] = "month";
    timePeriods["WEEK"] = "week";
    timePeriods["WEEKEND"] = "weekend";
    timePeriods["DAY"] = "day";
    timePeriods["MORNING"] = "morning";
    timePeriods["AFTERNOON"] = "afternoon";
    timePeriods["EVENING"] = "evening";
    timePeriods["NIGHT"] = "night";
    timePeriods["HOUR"] = "hour";
    timePeriods["MINUTE"] = "minute";
    timePeriods["NOW"] = "now";
})(timePeriods = exports.timePeriods || (exports.timePeriods = {}));
class DateTime {
    static get timePeriods() { return timePeriods; }
    constructor(input, nluTime, timezone) {
        if (nluTime instanceof Timezone_1.default) {
            timezone = nluTime;
            nluTime = null;
        }
        this.utc = NaN;
        this.timezone = null;
        this.durationDays = 0;
        this.durationHours = 0;
        this.durationMinutes = 0;
        this.timePeriod = null;
        this._localTime = null;
        if (typeof input === 'string' && Timezone_1.isoStringParser.test(input)) {
            if (!timezone) {
                timezone = Timezone_1.default.fromISOString(input);
            }
            input = new Date(input).getTime();
        }
        else if (input instanceof Date) {
            input = input.getTime();
        }
        if (typeof input === 'number') {
            this.utc = input;
            this.timezone = timezone || new Timezone_1.default();
            this.timePeriod = timePeriods.MINUTE;
        }
        else if (input && input.__type === 'DateTime') {
            this.utc = input.utc;
            this.timezone = new Timezone_1.default(input.timezone);
            this.durationDays = input.durationDays;
            this.durationHours = input.durationHours;
            this.durationMinutes = input.durationMinutes;
            this.timePeriod = input.timePeriod;
        }
        else if (input || nluTime || timezone) {
            this.timezone = timezone || new Timezone_1.default();
            this._parseInput(input, nluTime);
        }
        else {
            this.timezone = new Timezone_1.default();
            this._parseInput(input, nluTime);
        }
    }
    get utc() {
        return this._utc;
    }
    set utc(value) {
        this._utc = value;
        this._localTime = null;
    }
    get timezone() {
        return this._timezone;
    }
    set timezone(value) {
        this._timezone = value;
        this._localTime = null;
    }
    clone() {
        return new DateTime(this.toJSON());
    }
    jumpToNextDayPeriod() {
        let date = new Date(this.utc + this.timezone.offsetUTC);
        let hours = date.getUTCHours();
        if (hours < 6) {
            date.setUTCHours(6, 0, 0, 0);
            this.durationHours = 5;
            this.timePeriod = timePeriods.MORNING;
        }
        else if (hours < 12) {
            date.setUTCHours(12, 0, 0, 0);
            this.durationHours = 6;
            this.timePeriod = timePeriods.AFTERNOON;
        }
        else if (hours < 18) {
            date.setUTCHours(18, 0, 0, 0);
            this.durationHours = 4;
            this.timePeriod = timePeriods.EVENING;
        }
        else if (hours < 22) {
            date.setUTCHours(22, 0, 0, 0);
            this.durationHours = 7;
            this.timePeriod = timePeriods.NIGHT;
        }
        else {
            date.setUTCDate(date.getUTCDate() + 1);
            date.setUTCHours(6, 0, 0, 0);
        }
        this.utc = date.getTime() - this.timezone.offsetUTC;
    }
    addYear(years = 1) {
        let date = new Date(this.utc + this.timezone.offsetUTC);
        date.setUTCFullYear(date.getUTCFullYear() + years);
        this.utc = date.getTime() - this.timezone.offsetUTC;
    }
    addDays(days, zeroHours = false) {
        let date = new Date(this.utc + this.timezone.offsetUTC);
        date.setUTCDate(date.getUTCDate() + days);
        if (zeroHours) {
            date.setUTCHours(0, 0, 0, 0);
            this.timePeriod = timePeriods.DAY;
        }
        this.utc = date.getTime() - this.timezone.offsetUTC;
    }
    addHours(hours, zeroMinutes = false) {
        let date = new Date(this.utc + this.timezone.offsetUTC);
        date.setUTCHours(date.getUTCHours() + hours);
        if (zeroMinutes) {
            date.setUTCMinutes(0, 0, 0);
            this.timePeriod = timePeriods.HOUR;
        }
        this.utc = date.getTime() - this.timezone.offsetUTC;
    }
    setTime(hours, minutes, seconds = 0, milliseconds = 0) {
        let date = new Date(this.utc + this.timezone.offsetUTC);
        date.setUTCHours(hours, minutes || 0, seconds, milliseconds);
        this.utc = date.getTime() - this.timezone.offsetUTC;
        if (minutes !== undefined) {
            this.timePeriod = timePeriods.MINUTE;
        }
        else {
            this.timePeriod = timePeriods.HOUR;
        }
    }
    stripTime() {
        let timePeriod = this.timePeriod;
        if (timePeriod === timePeriods.HOUR || timePeriod === timePeriods.MINUTE ||
            timePeriod === timePeriods.MORNING || timePeriod === timePeriods.AFTERNOON ||
            timePeriod === timePeriods.EVENING || timePeriod === timePeriods.NIGHT ||
            timePeriod === timePeriods.NOW) {
            this.timePeriod = timePeriods.DAY;
            let date = new Date(this.utc + this.timezone.offsetUTC);
            date.setUTCHours(0, 0, 0, 0);
            this.utc = date.getTime() - this.timezone.offsetUTC;
            this.durationHours = this.durationMinutes = 0;
        }
    }
    isPast() {
        let endTime = this._utc;
        if (this.timePeriod === timePeriods.YEAR) {
            const endDate = new Date(endTime);
            endDate.setUTCFullYear(endDate.getUTCFullYear() + 1);
            endTime = endDate.getTime();
        }
        else if (this.timePeriod === timePeriods.MONTH) {
            const endDate = new Date(endTime);
            endDate.setUTCMonth(endDate.getUTCMonth() + 1);
            endTime = endDate.getTime();
        }
        else if (this.timePeriod === timePeriods.DAY) {
            const endDate = new Date(endTime);
            endDate.setUTCDate(endDate.getUTCDate() + 1);
            endTime = endDate.getTime();
        }
        if (this.durationDays) {
            endTime += this.durationDays * DAY_IN_MS;
        }
        if (this.durationHours) {
            endTime += this.durationHours * HOUR_IN_MS;
        }
        if (this.durationMinutes) {
            endTime += this.durationMinutes * 60 * 1000;
        }
        return endTime < Date.now();
    }
    isFuture() {
        return this._utc > Date.now();
    }
    isInRange(startDate, endDate) {
        try {
            const start = monthDateParser.exec(startDate);
            const end = monthDateParser.exec(endDate);
            const startMonth = parseInt(start[1]) - 1;
            const startDay = parseInt(start[2]);
            const endMonth = parseInt(end[1]) - 1;
            const endDay = parseInt(end[2]);
            const { monthNum, date } = this.getLocalTime();
            if (endMonth < startMonth || (endMonth === startMonth && endDay < startDay)) {
                if (startMonth > monthNum && endMonth < monthNum) {
                    return false;
                }
                if (startMonth === endMonth && monthNum === startMonth &&
                    (date > startDay || date < endDay)) {
                    return true;
                }
                if ((monthNum === startMonth && date < startDay) ||
                    (monthNum === endMonth && date > endDay)) {
                    return false;
                }
                return true;
            }
            else {
                if (monthNum < startMonth || monthNum > endMonth) {
                    return false;
                }
                if ((monthNum === startMonth && date < startDay) ||
                    (monthNum === endMonth && date > endDay)) {
                    return false;
                }
                return true;
            }
        }
        catch (e) {
            console.error(e);
            return false;
        }
    }
    getLocalTime() {
        if (!this._localTime) {
            const localDate = new Date(this.utc + this.timezone.offsetUTC);
            const month = localDate.getUTCMonth();
            this._localTime = {
                year: localDate.getUTCFullYear(),
                month: DateTimeUtils_1.default.MONTHS[month],
                monthNum: month,
                dayOfWeek: DateTimeUtils_1.default.DAYS_OF_WEEK[localDate.getUTCDay()],
                date: localDate.getUTCDate(),
                hour: localDate.getUTCHours(),
                minute: localDate.getUTCMinutes(),
                seconds: localDate.getUTCSeconds(),
                milliseconds: localDate.getUTCMilliseconds()
            };
        }
        return this._localTime;
    }
    getLocalMMDD() {
        let rtn = '';
        let date = new Date(this.utc + this.timezone.offsetUTC);
        let month = date.getUTCMonth() + 1;
        rtn += month < 10 ? '0' + month : month;
        let day = date.getUTCDate();
        rtn += day < 10 ? '0' + day : day;
        return rtn;
    }
    getLocalYYYYMMDD() {
        let rtn = '';
        let date = new Date(this.utc + this.timezone.offsetUTC);
        rtn += date.getUTCFullYear();
        let month = date.getUTCMonth() + 1;
        rtn += month < 10 ? '0' + month : month;
        let day = date.getUTCDate();
        rtn += day < 10 ? '0' + day : day;
        return rtn;
    }
    getRelativeDays() {
        let thisDate = new Date(this.utc + this.timezone.offsetUTC);
        let utc1 = Date.UTC(thisDate.getUTCFullYear(), thisDate.getUTCMonth(), thisDate.getUTCDate());
        let now = new Date(Date.now() + this.timezone.offsetUTC);
        let utc2 = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
        return Math.floor((utc1 - utc2) / DAY_IN_MS + 0.1);
    }
    getRelativeHours() {
        let thisDate = new Date(this.utc + this.timezone.offsetUTC);
        let utc1 = Date.UTC(thisDate.getUTCFullYear(), thisDate.getUTCMonth(), thisDate.getUTCDate(), thisDate.getUTCHours());
        let now = new Date(Date.now() + this.timezone.offsetUTC);
        let utc2 = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), now.getUTCHours());
        return Math.floor((utc1 - utc2) / HOUR_IN_MS + 0.1);
    }
    toString(options) {
        if (!options) {
            options = {};
        }
        if (options.suppressVerbalOutput) {
            return '';
        }
        let rtn = '';
        let thisDate = new Date(this.utc + this.timezone.offsetUTC);
        let relativeDays = this.getRelativeDays();
        let timePeriod = this.timePeriod;
        let wasLongPeriod = false;
        if (timePeriod === timePeriods.YEAR || timePeriod === timePeriods.MONTH ||
            timePeriod === timePeriods.WEEK || timePeriod === timePeriods.WEEKEND) {
            wasLongPeriod = true;
            let targetWeek, nowWeek, daysDiff, weeksDiff;
            switch (this.timePeriod) {
                case timePeriods.YEAR:
                    rtn = String(thisDate.getUTCFullYear());
                    break;
                case timePeriods.MONTH:
                    rtn = DateTimeUtils_1.default.MONTHS[thisDate.getUTCMonth()];
                    break;
                case timePeriods.WEEK:
                    targetWeek = new Date(this.utc + this.timezone.offsetUTC);
                    targetWeek.setUTCDate(targetWeek.getUTCDate() - targetWeek.getUTCDay() + 1);
                    nowWeek = new Date(Date.now() + this.timezone.offsetUTC);
                    nowWeek.setUTCDate(nowWeek.getUTCDate() - nowWeek.getUTCDay() + 1);
                    daysDiff = DateTimeUtils_1.default.getDaysBetweenDates(nowWeek, targetWeek);
                    weeksDiff = Math.round(daysDiff / 7);
                    if (weeksDiff === 0) {
                        rtn = 'this week';
                    }
                    else if (weeksDiff > 0) {
                        if (weeksDiff === 1) {
                            rtn = 'next week';
                        }
                        else {
                            rtn = weeksDiff + ' weeks from now';
                        }
                    }
                    else {
                        if (weeksDiff === -1) {
                            rtn = 'last week';
                        }
                        else {
                            rtn = Math.abs(weeksDiff) + ' weeks ago';
                        }
                    }
                    break;
                case timePeriods.WEEKEND:
                    targetWeek = new Date(this.utc + this.timezone.offsetUTC);
                    targetWeek.setUTCDate(targetWeek.getUTCDate() - targetWeek.getUTCDay() + 6);
                    nowWeek = new Date(Date.now() + this.timezone.offsetUTC);
                    nowWeek.setUTCDate(nowWeek.getUTCDate() - nowWeek.getUTCDay() + 6);
                    daysDiff = DateTimeUtils_1.default.getDaysBetweenDates(nowWeek, targetWeek);
                    weeksDiff = Math.round(daysDiff / 7);
                    if (weeksDiff === 0) {
                        rtn = 'this weekend';
                    }
                    else if (weeksDiff > 0) {
                        if (weeksDiff === 1) {
                            rtn = 'next weekend';
                        }
                        else {
                            rtn = weeksDiff + ' weekends from now';
                        }
                    }
                    else {
                        if (weeksDiff === -1) {
                            rtn = 'last weekend';
                        }
                        else {
                            rtn = Math.abs(weeksDiff) + ' weekends ago';
                        }
                    }
                    break;
            }
        }
        let usedDate = false;
        if (!wasLongPeriod && !options.timeOnly) {
            if (timePeriod === timePeriods.DAY || relativeDays !== 0 || options.dateOnly) {
                if (relativeDays === 0) {
                    rtn = 'today';
                }
                else if (relativeDays === -1) {
                    rtn = 'yesterday';
                }
                else if (relativeDays === 1) {
                    rtn = 'tomorrow';
                }
                else if (relativeDays < 7 && relativeDays > 0) {
                    rtn = DateTimeUtils_1.default.DAYS_OF_WEEK[thisDate.getUTCDay()];
                }
                else {
                    usedDate = true;
                    rtn = DateTimeUtils_1.default.MONTHS[thisDate.getUTCMonth()];
                    rtn += ' ' + DateTimeUtils_1.default.getOrdinal(thisDate.getUTCDate());
                    let now = new Date(Date.now() + this.timezone.offsetUTC);
                    if (now.getUTCFullYear() !== thisDate.getUTCFullYear()) {
                        rtn += ' ' + thisDate.getUTCFullYear();
                    }
                }
            }
        }
        if (!wasLongPeriod && !options.dateOnly) {
            if (timePeriod === timePeriods.MORNING) {
                if (usedDate) {
                    rtn = 'morning of ' + rtn;
                }
                else if (relativeDays === 0) {
                    rtn = 'this morning';
                }
                else {
                    rtn += ' morning';
                }
            }
            else if (timePeriod === timePeriods.AFTERNOON) {
                if (usedDate) {
                    rtn = 'afternoon of ' + rtn;
                }
                else if (relativeDays === 0) {
                    rtn = 'this afternoon';
                }
                else {
                    rtn += ' afternoon';
                }
            }
            else if (timePeriod === timePeriods.EVENING) {
                if (usedDate) {
                    rtn = 'evening of ' + rtn;
                }
                else if (relativeDays === 0) {
                    rtn = 'this evening';
                }
                else {
                    rtn += ' evening';
                }
            }
            else if (timePeriod === timePeriods.NIGHT) {
                if (usedDate) {
                    rtn = 'night of ' + rtn;
                }
                else if (relativeDays === 0) {
                    rtn = 'tonight';
                }
                else if (relativeDays === -1) {
                    rtn = 'last night';
                }
                else {
                    rtn += ' night';
                }
            }
            if (timePeriod === timePeriods.HOUR || timePeriod === timePeriods.MINUTE || timePeriod === timePeriods.NOW) {
                if (relativeDays !== 0 && !options.timeOnly) {
                    rtn += ' at ';
                }
                if (options.display) {
                    rtn += DateTimeUtils_1.default.getVisualTime(thisDate.getUTCHours(), thisDate.getUTCMinutes(), options.dropPeriod);
                }
                else {
                    rtn += DateTimeUtils_1.default.getVerbalTime(thisDate.getUTCHours(), thisDate.getUTCMinutes(), options.dropPeriod);
                }
            }
        }
        if (options.prefixOnAt) {
            if (timePeriod === timePeriods.YEAR || timePeriod === timePeriods.MONTH) {
                rtn = 'in ' + rtn;
            }
            else if (timePeriod === timePeriods.WEEK || timePeriod === timePeriods.WEEKEND) {
            }
            else if (!options.dateOnly &&
                (timePeriod === timePeriods.HOUR || timePeriod === timePeriods.MINUTE ||
                    timePeriod === timePeriods.NOW || options.timeOnly)) {
                if (relativeDays === 0 || options.timeOnly) {
                    rtn = 'at ' + rtn;
                }
                else if (relativeDays === -1 || relativeDays === 1) {
                }
                else {
                    rtn = 'on ' + rtn;
                }
            }
            else if (relativeDays === 0 || relativeDays === -1 || relativeDays === 1) {
            }
            else {
                rtn = 'on ' + rtn;
            }
        }
        return rtn;
    }
    prefixOnAt(options) {
        if (!options) {
            options = {};
        }
        options.prefixOnAt = true;
        return this.toString(options);
    }
    toMoment() {
        if (Date.now() - this._utc < 0) {
            return 'The Future';
        }
        const diffInMin = (Date.now() - this._utc) / (1000 * 60);
        if (diffInMin <= 30) {
            return 'Just Now';
        }
        if (diffInMin <= 60) {
            return `${Math.floor(diffInMin)}m ago`;
        }
        const diffInHours = diffInMin / 60;
        if (diffInHours <= 24) {
            return `${Math.floor(diffInHours)}h ago`;
        }
        const relativeDays = -this.getRelativeDays();
        if (relativeDays <= 7) {
            return relativeDays === 1 ? 'Yesterday' : `${relativeDays}d ago`;
        }
        const local = this.getLocalTime();
        const now = new DateTime(Date.now(), this._timezone).getLocalTime();
        let date = DateTimeUtils_1.default.MONTH_ABBREVIATIONS[local.monthNum] + ' ';
        if (local.year === now.year) {
            date += DateTimeUtils_1.default.getOrdinal(local.date);
        }
        else {
            date += local.date + ' ' + local.year;
        }
        return date;
    }
    toJSON() {
        return {
            __type: 'DateTime',
            utc: this.utc,
            timezone: this.timezone.toJSON(),
            durationDays: this.durationDays,
            durationHours: this.durationHours,
            durationMinutes: this.durationMinutes,
            timePeriod: this.timePeriod
        };
    }
    toISOString() {
        const local = this.getLocalTime();
        return `${pad(local.year, 4)}-${pad((local.monthNum + 1), 2)}-${pad(local.date, 2)}T${pad(local.hour, 2)}:${pad(local.minute, 2)}:${pad(local.seconds, 2)}.${pad(local.milliseconds, 3)}` + this._timezone.toISOString();
    }
    toLog() {
        return this.toJSON();
    }
    _parseInput(nluDate, nluTime) {
        if (nluDate === 'null') {
            nluDate = null;
        }
        if (nluTime === 'null') {
            nluTime = null;
        }
        let dateUTC = null;
        let dayNotSpecified = false;
        let isToday = false;
        if (!nluDate) {
            dateUTC = new Date(Date.now() + this.timezone.offsetUTC);
            dayNotSpecified = true;
            isToday = true;
        }
        else if (relativeDayParser.test(nluDate)) {
            dateUTC = new Date(Date.now() + this.timezone.offsetUTC);
            let regexResult = relativeDayParser.exec(nluDate);
            if (regexResult[2] === 'd') {
                let relativeDay = parseInt(regexResult[1], 10);
                if (relativeDay !== 0) {
                    dateUTC.setUTCDate(dateUTC.getUTCDate() + relativeDay);
                }
                else {
                    isToday = true;
                }
                this.timePeriod = timePeriods.DAY;
            }
            else if (regexResult[2] === 'wd') {
                let numWeeksAhead = parseInt(regexResult[1], 10);
                let dayOfWeek = dateUTC.getUTCDay();
                let relativeDay = numWeeksAhead * 7 + (6 - dayOfWeek);
                if (dayOfWeek === 0) {
                    relativeDay -= 7;
                }
                if (relativeDay !== 0) {
                    dateUTC.setUTCDate(dateUTC.getUTCDate() + relativeDay);
                }
                this.durationDays = 2;
                this.timePeriod = timePeriods.WEEKEND;
            }
            else if (regexResult[2] === 'w') {
                let numWeeksAhead = parseInt(regexResult[1], 10);
                let dayOfWeek = dateUTC.getUTCDay();
                let relativeDay = numWeeksAhead * 7 - dayOfWeek + 1;
                if (relativeDay !== 0) {
                    dateUTC.setUTCDate(dateUTC.getUTCDate() + relativeDay);
                }
                this.durationDays = 7;
                this.timePeriod = timePeriods.WEEK;
            }
            else if (regexResult[2] === 'm') {
                let relativeMonth = parseInt(regexResult[1], 10);
                dateUTC.setUTCMonth(dateUTC.getUTCMonth() + relativeMonth, 1);
                this.timePeriod = timePeriods.MONTH;
            }
            else if (regexResult[2] === 'y') {
                let relativeYear = parseInt(regexResult[1], 10) * 365;
                dateUTC.setUTCFullYear(dateUTC.getUTCFullYear() + relativeYear, 0, 1);
                this.timePeriod = timePeriods.YEAR;
            }
        }
        else if (dateParser.test(nluDate)) {
            dateUTC = new Date(Date.now() + this.timezone.offsetUTC);
            let date = parseInt(dateParser.exec(nluDate)[1], 10);
            let daysInCurrentMonth = new Date(dateUTC.getUTCFullYear(), dateUTC.getUTCMonth() + 1, 0).getUTCDate();
            if (dateUTC.getUTCDate() < date && date <= daysInCurrentMonth) {
                dateUTC.setUTCDate(date);
            }
            else {
                dateUTC.setUTCMonth(dateUTC.getUTCMonth() + 1);
                dateUTC.setUTCDate(date);
            }
            this.timePeriod = timePeriods.DAY;
        }
        else if (monthDateParser.test(nluDate)) {
            let regexResult = monthDateParser.exec(nluDate);
            dateUTC = new Date(Date.now() + this.timezone.offsetUTC);
            let month = parseInt(regexResult[1], 10) - 1;
            let date = parseInt(regexResult[2], 10);
            let nowMonth = dateUTC.getUTCMonth();
            if (month < nowMonth || (month === nowMonth && date < dateUTC.getUTCDate())) {
                dateUTC.setUTCFullYear(dateUTC.getUTCFullYear() + 1);
            }
            dateUTC.setUTCMonth(month);
            dateUTC.setUTCDate(date);
            this.timePeriod = timePeriods.DAY;
        }
        else if (fullDateParser.test(nluDate)) {
            let regexResult = fullDateParser.exec(nluDate);
            dateUTC = new Date(Date.UTC(parseInt(regexResult[3], 10), parseInt(regexResult[1], 10) - 1, parseInt(regexResult[2], 10)));
            this.timePeriod = timePeriods.DAY;
        }
        else if (dayOfWeekParser.test(nluDate)) {
            let regexResult = dayOfWeekParser.exec(nluDate);
            let dow = regexResult[1];
            dateUTC = new Date(Date.now() + this.timezone.offsetUTC);
            let relativeDay = DateTimeUtils_1.default.DAYS_OF_WEEK[dow] - dateUTC.getUTCDay();
            if (relativeDay < 0) {
                relativeDay += 7;
            }
            if (pastDOWParser.test(regexResult[2])) {
                regexResult = pastDOWParser.exec(regexResult[2]);
                let weeksDiff = parseInt(regexResult[1], 10);
                relativeDay += weeksDiff * 7;
            }
            if (relativeDay !== 0) {
                dateUTC.setUTCDate(dateUTC.getUTCDate() + relativeDay);
            }
            else {
                isToday = true;
            }
            this.timePeriod = timePeriods.DAY;
        }
        else if (monthNameParser.test(nluDate)) {
            let regexResult = monthNameParser.exec(nluDate);
            let monthNum = DateTimeUtils_1.default.MONTHS.indexOf(regexResult[1].toLowerCase());
            dateUTC = new Date(Date.now() + this.timezone.offsetUTC);
            if (monthNum < dateUTC.getUTCMonth()) {
                dateUTC.setUTCFullYear(dateUTC.getUTCFullYear() + 1, monthNum, 1);
            }
            else {
                dateUTC.setUTCMonth(monthNum, 1);
            }
            this.timePeriod = timePeriods.MONTH;
        }
        else if (yearParser.test(nluDate)) {
            let regexResult = yearParser.exec(nluDate);
            dateUTC.setUTCFullYear(parseInt(regexResult[1], 10), 0, 1);
            this.timePeriod = timePeriods.YEAR;
        }
        if (!nluTime) {
            if (dayNotSpecified) {
                this.timePeriod = timePeriods.NOW;
            }
            else {
                dateUTC.setUTCHours(0, 0, 0, 0);
            }
        }
        else {
            if (nluTime === 'noon') {
                dateUTC.setUTCHours(12, 0, 0, 0);
                this.timePeriod = timePeriods.HOUR;
            }
            else if (nluTime === 'midnight') {
                dateUTC.setUTCHours(24, 0, 0, 0);
                this.timePeriod = timePeriods.HOUR;
            }
            else if (nluTime === 'morning') {
                dateUTC.setUTCHours(6, 0, 0, 0);
                this.durationHours = 5;
                this.timePeriod = timePeriods.MORNING;
            }
            else if (nluTime === 'afternoon') {
                dateUTC.setUTCHours(12, 0, 0, 0);
                this.durationHours = 6;
                this.timePeriod = timePeriods.AFTERNOON;
            }
            else if (nluTime === 'evening') {
                dateUTC.setUTCHours(18, 0, 0, 0);
                this.durationHours = 4;
                this.timePeriod = timePeriods.EVENING;
            }
            else if (nluTime === 'night') {
                dateUTC.setUTCHours(22, 0, 0, 0);
                this.durationHours = 7;
                this.timePeriod = timePeriods.NIGHT;
            }
            else if (timeParser.test(nluTime)) {
                let timeSplit = timeParser.exec(nluTime);
                let hoursIn12H = parseInt(timeSplit[1], 10);
                let minutes = parseInt(timeSplit[2], 10);
                switch (timeSplit[3]) {
                    case 'AM':
                        if (hoursIn12H === 12) {
                            dateUTC.setUTCHours(0);
                        }
                        else {
                            dateUTC.setUTCHours(hoursIn12H);
                        }
                        break;
                    case 'PM':
                        if (hoursIn12H !== 12) {
                            dateUTC.setUTCHours(hoursIn12H + 12);
                        }
                        else {
                            dateUTC.setUTCHours(hoursIn12H);
                        }
                        break;
                    default:
                        if (hoursIn12H === 12 || hoursIn12H < 6) {
                            let hoursIn24H = hoursIn12H === 12 ? hoursIn12H : hoursIn12H + 12;
                            if (dayNotSpecified) {
                                let nowHour = dateUTC.getUTCHours();
                                let nowMinutes = dateUTC.getUTCMinutes();
                                if (nowHour > hoursIn24H ||
                                    (nowHour === hoursIn24H && nowMinutes >= minutes)) {
                                    dateUTC.setUTCDate(dateUTC.getUTCDate() + 1);
                                    dateUTC.setUTCHours(hoursIn24H);
                                }
                                else {
                                    dateUTC.setUTCHours(hoursIn24H);
                                }
                            }
                            else {
                                dateUTC.setUTCHours(hoursIn24H);
                            }
                        }
                        else if (isToday) {
                            let nowHour = dateUTC.getUTCHours();
                            let nowMinutes = dateUTC.getUTCMinutes();
                            if (nowHour < 12) {
                                if (hoursIn12H > nowHour ||
                                    (hoursIn12H === nowHour && minutes > nowMinutes)) {
                                    dateUTC.setUTCHours(hoursIn12H);
                                }
                                else {
                                    dateUTC.setUTCHours(hoursIn12H + 12);
                                }
                            }
                            else {
                                let hoursIn24H = hoursIn12H === 12 ? hoursIn12H : hoursIn12H + 12;
                                if (hoursIn24H < nowHour ||
                                    (hoursIn24H === nowHour && minutes < nowMinutes)) {
                                    if (dayNotSpecified) {
                                        dateUTC.setUTCDate(dateUTC.getUTCDate() + 1);
                                        dateUTC.setUTCHours(hoursIn12H);
                                    }
                                    else {
                                        dateUTC.setUTCHours(hoursIn24H);
                                    }
                                }
                                else {
                                    dateUTC.setUTCHours(hoursIn24H);
                                }
                            }
                        }
                        else {
                            dateUTC.setUTCHours(hoursIn12H);
                        }
                }
                dateUTC.setUTCMinutes(minutes, 0, 0);
                this.timePeriod = minutes === 0 ? timePeriods.HOUR : timePeriods.MINUTE;
            }
            else if (relativeTimeParser.test(nluTime)) {
                let regexResult = relativeTimeParser.exec(nluTime);
                let relativeHours = parseInt(regexResult[2], 10);
                let relativeMinutes = parseInt(regexResult[3], 10);
                let relativeSeconds = parseInt(regexResult[4], 10);
                if (regexResult[1] === '-') {
                    relativeHours = -relativeHours;
                    relativeMinutes = -relativeMinutes;
                    relativeSeconds = -relativeSeconds;
                }
                if (relativeHours !== 0) {
                    dateUTC.setUTCHours(dateUTC.getUTCHours() + relativeHours);
                }
                if (relativeMinutes !== 0) {
                    dateUTC.setUTCMinutes(dateUTC.getUTCMinutes() + relativeMinutes);
                }
                if (relativeSeconds !== 0) {
                    dateUTC.setUTCSeconds(dateUTC.getUTCSeconds() + relativeSeconds);
                }
                this.timePeriod = timePeriods.MINUTE;
            }
        }
        this.utc = dateUTC.getTime() - this.timezone.offsetUTC;
    }
}
exports.default = DateTime;

},{"../location/Timezone":3,"./DateTimeUtils":5}],5:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var DateTimeUtils;
(function (DateTimeUtils) {
    DateTimeUtils.MONTHS = [
        'january',
        'february',
        'march',
        'april',
        'may',
        'june',
        'july',
        'august',
        'september',
        'october',
        'november',
        'december'
    ];
    DateTimeUtils.MONTH_ABBREVIATIONS = [
        'Jan',
        'Feb',
        'Mar',
        'Apr',
        'May',
        'Jun',
        'Jul',
        'Aug',
        'Sep',
        'Oct',
        'Nov',
        'Dec'
    ];
    DateTimeUtils.DAYS_OF_WEEK = [
        'sunday',
        'monday',
        'tuesday',
        'wednesday',
        'thursday',
        'friday',
        'saturday'
    ];
    DateTimeUtils.MS_PER_DAY = 1000 * 60 * 60 * 24;
    let DiffUnit;
    (function (DiffUnit) {
        DiffUnit[DiffUnit["Milliseconds"] = 0] = "Milliseconds";
        DiffUnit[DiffUnit["Seconds"] = 1] = "Seconds";
        DiffUnit[DiffUnit["Minutes"] = 2] = "Minutes";
        DiffUnit[DiffUnit["Hours"] = 3] = "Hours";
        DiffUnit[DiffUnit["Days"] = 4] = "Days";
        DiffUnit[DiffUnit["Weeks"] = 5] = "Weeks";
    })(DiffUnit = DateTimeUtils.DiffUnit || (DateTimeUtils.DiffUnit = {}));
    function getVerbalNumber(input) {
        if (input === 0) {
            return 'zero';
        }
        let returnVal = input < 0 ? 'negative ' : '';
        input = Math.abs(input);
        let tens = input / 10 | 0;
        let ones = input % 10 | 0;
        switch (tens) {
            case 1:
                switch (ones) {
                    case 0:
                        returnVal += 'ten';
                        break;
                    case 1:
                        returnVal += 'eleven';
                        break;
                    case 2:
                        returnVal += 'twelve';
                        break;
                    case 3:
                        returnVal += 'thirteen';
                        break;
                    case 4:
                        returnVal += 'fourteen';
                        break;
                    case 5:
                        returnVal += 'fifteen';
                        break;
                    case 6:
                        returnVal += 'sixteen';
                        break;
                    case 7:
                        returnVal += 'seventeen';
                        break;
                    case 8:
                        returnVal += 'eighteen';
                        break;
                    case 9:
                        returnVal += 'nineteen';
                        break;
                }
                break;
            case 2:
                returnVal += 'twenty';
                break;
            case 3:
                returnVal += 'thirty';
                break;
            case 4:
                returnVal += 'forty';
                break;
            case 5:
                returnVal += 'fifty';
                break;
            case 6:
                returnVal += 'sixty';
                break;
            case 7:
                returnVal += 'seventy';
                break;
            case 8:
                returnVal += 'eighty';
                break;
            case 9:
                returnVal += 'ninety';
                break;
        }
        if (tens !== 1) {
            if (tens !== 0 && ones !== 0) {
                returnVal += ' ';
            }
            switch (ones) {
                case 1:
                    returnVal += 'one';
                    break;
                case 2:
                    returnVal += 'two';
                    break;
                case 3:
                    returnVal += 'three';
                    break;
                case 4:
                    returnVal += 'four';
                    break;
                case 5:
                    returnVal += 'five';
                    break;
                case 6:
                    returnVal += 'six';
                    break;
                case 7:
                    returnVal += 'seven';
                    break;
                case 8:
                    returnVal += 'eight';
                    break;
                case 9:
                    returnVal += 'nine';
                    break;
            }
        }
        return returnVal;
    }
    DateTimeUtils.getVerbalNumber = getVerbalNumber;
    function getOrdinal(num) {
        if (num === 0) {
            return 'zero';
        }
        if (num < 20 && num > 10) {
            return String(num) + 'th';
        }
        switch (num % 10) {
            case 1:
                return String(num) + 'st';
            case 2:
                return String(num) + 'nd';
            case 3:
                return String(num) + 'rd';
            default:
                return String(num) + 'th';
        }
    }
    DateTimeUtils.getOrdinal = getOrdinal;
    function getVerbalTime(hour, minute = 0, dropPeriod = false) {
        if (dropPeriod) {
            if (hour >= 12) {
                if (hour > 12) {
                    hour -= 12;
                }
            }
            else if (hour === 0) {
                hour = 12;
            }
            let time = getVerbalNumber(hour) + ' ';
            if (minute === 0) {
                time += 'oh clock';
            }
            else if (minute < 10) {
                time += 'oh ' + getVerbalNumber(minute);
            }
            else {
                time += getVerbalNumber(minute);
            }
            return time;
        }
        else {
            return getVisualTime(hour, minute);
        }
    }
    DateTimeUtils.getVerbalTime = getVerbalTime;
    function getVisualTime(hour, minute, dropPeriod = false) {
        let period = 'AM';
        if (hour >= 12) {
            period = 'PM';
            if (hour > 12) {
                hour -= 12;
            }
        }
        else if (hour === 0) {
            hour = 12;
        }
        let minuteName = '';
        if (minute !== null) {
            minuteName = ':';
            minute = minute || 0;
            if (minute < 10) {
                minuteName += '0';
            }
            minuteName += minute;
        }
        let hourName = String(hour === 0 ? 12 : hour);
        if (dropPeriod) {
            return `${hourName}${minuteName}`;
        }
        return `${hourName}${minuteName} ${period}`;
    }
    DateTimeUtils.getVisualTime = getVisualTime;
    function getVerbalTimeFrom24Hour(time) {
        return getVerbalTime(parseInt(time.substr(0, 2), 10), parseInt(time.substr(2, 2), 10));
    }
    DateTimeUtils.getVerbalTimeFrom24Hour = getVerbalTimeFrom24Hour;
    function getVisualTimeFrom24Hour(time) {
        return getVisualTime(parseInt(time.substr(0, 2), 10), parseInt(time.substr(2, 2), 10));
    }
    DateTimeUtils.getVisualTimeFrom24Hour = getVisualTimeFrom24Hour;
    function getDaysBetweenDates(a, b) {
        const utc1 = Date.UTC(a.getUTCFullYear(), a.getUTCMonth(), a.getUTCDate());
        const utc2 = Date.UTC(b.getUTCFullYear(), b.getUTCMonth(), b.getUTCDate());
        return Math.floor((utc2 - utc1) / this.MS_PER_DAY + 0.1);
    }
    DateTimeUtils.getDaysBetweenDates = getDaysBetweenDates;
    function diffDateTimes(a, b, unit = DiffUnit.Milliseconds) {
        let diff = b.utc - a.utc;
        if (unit > DiffUnit.Milliseconds) {
            diff /= 1000;
        }
        if (unit > DiffUnit.Seconds) {
            diff /= 60;
        }
        if (unit > DiffUnit.Minutes) {
            diff /= 60;
        }
        if (unit > DiffUnit.Hours) {
            diff /= 24;
        }
        if (unit > DiffUnit.Days) {
            diff /= 7;
        }
        return diff;
    }
    DateTimeUtils.diffDateTimes = diffDateTimes;
})(DateTimeUtils || (DateTimeUtils = {}));
exports.default = DateTimeUtils;

},{}],6:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Timezone_1 = require("./location/Timezone");
exports.Timezone = Timezone_1.default;
var DateTime_1 = require("./time/DateTime");
exports.DateTime = DateTime_1.default;
var DateTimeUtils_1 = require("./time/DateTimeUtils");
exports.DateTimeUtils = DateTimeUtils_1.default;
var Location_1 = require("./location/Location");
exports.Location = Location_1.default;
exports.setHome = Location_1.setHome;
var LocationUtils_1 = require("./location/LocationUtils");
exports.LocationUtils = LocationUtils_1.LocationUtils;
const Location_2 = require("./location/Location");
function initLog(parentLog) {
    Location_2.initLog(parentLog);
}
exports.initLog = initLog;

},{"./location/Location":1,"./location/LocationUtils":2,"./location/Timezone":3,"./time/DateTime":4,"./time/DateTimeUtils":5}]},{},[6])(6)
});

//# sourceMappingURL=jibo-data-utils.js.map