@fossa-app/bridge 0.1.9 → 0.1.11

package/dist/fable_modules/fable-library-ts.5.0.0-rc.1/Date.js

@@ -1,812 +0,0 @@
-"use strict";
-/**
- * DateTimeOffset functions.
- *
- * Note: Date instances are always DateObjects in local
- * timezone (because JS dates are all kinds of messed up).
- * A local date returns UTC epoch when `.getTime()` is called.
- *
- * Basically; invariant: date.getTime() always return UTC time.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareTo = exports.compare = void 0;
-exports.getKind = getKind;
-exports.unixEpochMillisecondsToTicks = unixEpochMillisecondsToTicks;
-exports.ticksToUnixEpochMilliseconds = ticksToUnixEpochMilliseconds;
-exports.dateOffsetToString = dateOffsetToString;
-exports.toString = toString;
-exports.DateTime = DateTime;
-exports.fromTicks = fromTicks;
-exports.fromDateTime = fromDateTime;
-exports.fromDateTimeOffset = fromDateTimeOffset;
-exports.getTicks = getTicks;
-exports.minValue = minValue;
-exports.maxValue = maxValue;
-exports.parseRaw = parseRaw;
-exports.parse = parse;
-exports.tryParse = tryParse;
-exports.create = create;
-exports.now = now;
-exports.utcNow = utcNow;
-exports.today = today;
-exports.isLeapYear = isLeapYear;
-exports.daysInMonth = daysInMonth;
-exports.toUniversalTime = toUniversalTime;
-exports.toLocalTime = toLocalTime;
-exports.specifyKind = specifyKind;
-exports.timeOfDay = timeOfDay;
-exports.date = date;
-exports.day = day;
-exports.hour = hour;
-exports.millisecond = millisecond;
-exports.minute = minute;
-exports.month = month;
-exports.second = second;
-exports.year = year;
-exports.dayOfWeek = dayOfWeek;
-exports.dayOfYear = dayOfYear;
-exports.add = add;
-exports.addDays = addDays;
-exports.addHours = addHours;
-exports.addMinutes = addMinutes;
-exports.addSeconds = addSeconds;
-exports.addMilliseconds = addMilliseconds;
-exports.addTicks = addTicks;
-exports.addYears = addYears;
-exports.addMonths = addMonths;
-exports.subtract = subtract;
-exports.toLongDateString = toLongDateString;
-exports.toShortDateString = toShortDateString;
-exports.toLongTimeString = toLongTimeString;
-exports.toShortTimeString = toShortTimeString;
-exports.equals = equals;
-exports.op_Addition = op_Addition;
-exports.op_Subtraction = op_Subtraction;
-exports.isDaylightSavingTime = isDaylightSavingTime;
-const BigInt_ts_1 = require("./BigInt.js");
-const Util_ts_1 = require("./Util.js");
-const shortDays = [
-    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
-];
-const longDays = [
-    "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
-];
-const shortMonths = [
-    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-];
-const longMonths = [
-    "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
-];
-function parseRepeatToken(format, pos, patternChar) {
-    let tokenLength = 0;
-    let internalPos = pos;
-    while (internalPos < format.length && format[internalPos] === patternChar) {
-        internalPos++;
-        tokenLength++;
-    }
-    return tokenLength;
-}
-function parseNextChar(format, pos) {
-    if (pos >= format.length - 1) {
-        return -1;
-    }
-    return format.charCodeAt(pos + 1);
-}
-function parseQuotedString(format, pos) {
-    let beginPos = pos;
-    // Get the character used to quote the string
-    const quoteChar = format[pos];
-    let result = "";
-    let foundQuote = false;
-    while (pos < format.length) {
-        pos++;
-        const currentChar = format[pos];
-        if (currentChar === quoteChar) {
-            foundQuote = true;
-            break;
-        }
-        else if (currentChar === "\\") {
-            if (pos < format.length) {
-                pos++;
-                result += format[pos];
-            }
-            else {
-                // This means that '\' is the last character in the string.
-                throw new Util_ts_1.Exception("Invalid string format");
-            }
-        }
-        else {
-            result += currentChar;
-        }
-    }
-    if (!foundQuote) {
-        // We could not find the matching quote
-        throw new Util_ts_1.Exception(`Invalid string format could not find matching quote for ${quoteChar}`);
-    }
-    return [result, pos - beginPos + 1];
-}
-function dateToStringWithCustomFormat(date, format, utc) {
-    let cursorPos = 0;
-    let tokenLength = 0;
-    let result = "";
-    const localizedDate = utc ? DateTime(date.getTime(), Util_ts_1.DateTimeKind.Utc) : date;
-    while (cursorPos < format.length) {
-        const token = format[cursorPos];
-        switch (token) {
-            case "d":
-                tokenLength = parseRepeatToken(format, cursorPos, "d");
-                cursorPos += tokenLength;
-                switch (tokenLength) {
-                    case 1:
-                        result += day(localizedDate);
-                        break;
-                    case 2:
-                        result += (0, Util_ts_1.padWithZeros)(day(localizedDate), 2);
-                        break;
-                    case 3:
-                        result += shortDays[dayOfWeek(localizedDate)];
-                        break;
-                    case 4:
-                    default:
-                        result += longDays[dayOfWeek(localizedDate)];
-                        break;
-                }
-                break;
-            case "f":
-                tokenLength = parseRepeatToken(format, cursorPos, "f");
-                cursorPos += tokenLength;
-                if (tokenLength <= 3) {
-                    const precision = 10 ** (3 - tokenLength);
-                    result += (0, Util_ts_1.padWithZeros)(Math.floor(millisecond(localizedDate) / precision), tokenLength);
-                }
-                else if (tokenLength <= 7) {
-                    // JavaScript Date only support precision to the millisecond
-                    // so we fill the rest of the precision with 0 as if the date didn't have
-                    // milliseconds provided to it.
-                    // This is to have the same behavior as .NET when doing:
-                    // DateTime(1, 2, 3, 4, 5, 6, DateTimeKind.Utc).ToString("fffff") => 00000
-                    result += ("" + millisecond(localizedDate)).padEnd(tokenLength, "0");
-                }
-                else {
-                    throw "Input string was not in a correct format.";
-                }
-                break;
-            case "F":
-                tokenLength = parseRepeatToken(format, cursorPos, "F");
-                cursorPos += tokenLength;
-                if (tokenLength <= 3) {
-                    const precision = 10 ** (3 - tokenLength);
-                    const value = Math.floor(millisecond(localizedDate) / precision);
-                    if (value != 0) {
-                        result += (0, Util_ts_1.padWithZeros)(value, tokenLength);
-                    }
-                }
-                else if (tokenLength <= 7) {
-                    // JavaScript Date only support precision to the millisecond
-                    // so we can't go beyond that.
-                    // We also need to pad start with 0 if the value is not 0
-                    const value = millisecond(localizedDate);
-                    if (value != 0) {
-                        result += (0, Util_ts_1.padWithZeros)(value, 3);
-                    }
-                }
-                else {
-                    throw "Input string was not in a correct format.";
-                }
-                break;
-            case "g":
-                tokenLength = parseRepeatToken(format, cursorPos, "g");
-                cursorPos += tokenLength;
-                result += "A.D.";
-                break;
-            case "h":
-                tokenLength = parseRepeatToken(format, cursorPos, "h");
-                cursorPos += tokenLength;
-                switch (tokenLength) {
-                    case 1:
-                        const h1Value = hour(localizedDate) % 12;
-                        result += h1Value ? h1Value : 12;
-                        break;
-                    case 2:
-                    default:
-                        const h2Value = hour(localizedDate) % 12;
-                        result += (0, Util_ts_1.padWithZeros)(h2Value ? h2Value : 12, 2);
-                        break;
-                }
-                break;
-            case "H":
-                tokenLength = parseRepeatToken(format, cursorPos, "H");
-                cursorPos += tokenLength;
-                switch (tokenLength) {
-                    case 1:
-                        result += hour(localizedDate);
-                        break;
-                    case 2:
-                    default:
-                        result += (0, Util_ts_1.padWithZeros)(hour(localizedDate), 2);
-                        break;
-                }
-                break;
-            case "K":
-                tokenLength = parseRepeatToken(format, cursorPos, "K");
-                cursorPos += tokenLength;
-                switch (tokenLength) {
-                    case 1:
-                        switch (getKind(localizedDate)) {
-                            case Util_ts_1.DateTimeKind.Utc:
-                                result += "Z";
-                                break;
-                            case Util_ts_1.DateTimeKind.Local:
-                                result += dateOffsetToString(localizedDate.getTimezoneOffset() * -60000);
-                                break;
-                            case Util_ts_1.DateTimeKind.Unspecified:
-                                break;
-                        }
-                        break;
-                    default:
-                        break;
-                }
-                break;
-            case "m":
-                tokenLength = parseRepeatToken(format, cursorPos, "m");
-                cursorPos += tokenLength;
-                switch (tokenLength) {
-                    case 1:
-                        result += minute(localizedDate);
-                        break;
-                    case 2:
-                    default:
-                        result += (0, Util_ts_1.padWithZeros)(minute(localizedDate), 2);
-                        break;
-                }
-                break;
-            case "M":
-                tokenLength = parseRepeatToken(format, cursorPos, "M");
-                cursorPos += tokenLength;
-                switch (tokenLength) {
-                    case 1:
-                        result += month(localizedDate);
-                        break;
-                    case 2:
-                        result += (0, Util_ts_1.padWithZeros)(month(localizedDate), 2);
-                        break;
-                    case 3:
-                        result += shortMonths[month(localizedDate) - 1];
-                        break;
-                    case 4:
-                    default:
-                        result += longMonths[month(localizedDate) - 1];
-                        break;
-                }
-                break;
-            case "s":
-                tokenLength = parseRepeatToken(format, cursorPos, "s");
-                cursorPos += tokenLength;
-                switch (tokenLength) {
-                    case 1:
-                        result += second(localizedDate);
-                        break;
-                    case 2:
-                    default:
-                        result += (0, Util_ts_1.padWithZeros)(second(localizedDate), 2);
-                        break;
-                }
-                break;
-            case "t":
-                tokenLength = parseRepeatToken(format, cursorPos, "t");
-                cursorPos += tokenLength;
-                switch (tokenLength) {
-                    case 1:
-                        result += localizedDate.getHours() < 12 ? "A" : "P";
-                        break;
-                    case 2:
-                    default:
-                        result += localizedDate.getHours() < 12 ? "AM" : "PM";
-                        break;
-                }
-                break;
-            case "y":
-                tokenLength = parseRepeatToken(format, cursorPos, "y");
-                cursorPos += tokenLength;
-                switch (tokenLength) {
-                    case 1:
-                        result += localizedDate.getFullYear() % 100;
-                        break;
-                    case 2:
-                        result += (0, Util_ts_1.padWithZeros)(localizedDate.getFullYear() % 100, 2);
-                        break;
-                    default:
-                        result += (0, Util_ts_1.padWithZeros)(localizedDate.getFullYear(), tokenLength);
-                        break;
-                }
-                break;
-            case "z":
-                tokenLength = parseRepeatToken(format, cursorPos, "z");
-                cursorPos += tokenLength;
-                let utcOffsetText = "";
-                switch (getKind(localizedDate)) {
-                    case Util_ts_1.DateTimeKind.Utc:
-                        utcOffsetText = "+00:00";
-                        break;
-                    case Util_ts_1.DateTimeKind.Local:
-                        utcOffsetText = dateOffsetToString(localizedDate.getTimezoneOffset() * -60000);
-                        break;
-                    case Util_ts_1.DateTimeKind.Unspecified:
-                        utcOffsetText = dateOffsetToString(toLocalTime(localizedDate).getTimezoneOffset() * -60000);
-                        break;
-                }
-                const sign = utcOffsetText[0] === "-" ? "-" : "+";
-                const hours = parseInt(utcOffsetText.substring(1, 3), 10);
-                const minutes = parseInt(utcOffsetText.substring(4, 6), 10);
-                switch (tokenLength) {
-                    case 1:
-                        result += `${sign}${hours}`;
-                        break;
-                    case 2:
-                        result += `${sign}${(0, Util_ts_1.padWithZeros)(hours, 2)}`;
-                        break;
-                    default:
-                        result += `${sign}${(0, Util_ts_1.padWithZeros)(hours, 2)}:${(0, Util_ts_1.padWithZeros)(minutes, 2)}`;
-                        break;
-                }
-                break;
-            case ":":
-                result += ":";
-                cursorPos++;
-                break;
-            case "/":
-                result += "/";
-                cursorPos++;
-                break;
-            case "'":
-            case '"':
-                const [quotedString, quotedStringLenght] = parseQuotedString(format, cursorPos);
-                result += quotedString;
-                cursorPos += quotedStringLenght;
-                break;
-            case "%":
-                const nextChar = parseNextChar(format, cursorPos);
-                if (nextChar >= 0 && nextChar !== "%".charCodeAt(0)) {
-                    cursorPos += 2;
-                    result += dateToStringWithCustomFormat(localizedDate, String.fromCharCode(nextChar), utc);
-                }
-                else {
-                    throw new Util_ts_1.Exception("Invalid format string");
-                }
-                break;
-            case "\\":
-                const nextChar2 = parseNextChar(format, cursorPos);
-                if (nextChar2 >= 0) {
-                    cursorPos += 2;
-                    result += String.fromCharCode(nextChar2);
-                }
-                else {
-                    throw new Util_ts_1.Exception("Invalid format string");
-                }
-                break;
-            default:
-                cursorPos++;
-                result += token;
-                break;
-        }
-    }
-    return result;
-}
-function getKind(value) {
-    return value.kind ?? Util_ts_1.DateTimeKind.Unspecified;
-}
-function unixEpochMillisecondsToTicks(ms, offset) {
-    return (0, BigInt_ts_1.toInt64)(((BigInt(ms) + 62135596800000n) + BigInt(offset)) * 10000n);
-}
-function ticksToUnixEpochMilliseconds(ticks) {
-    return Number(((BigInt(ticks) / 10000n) - 62135596800000n));
-}
-function dateOffsetToString(offset) {
-    const isMinus = offset < 0;
-    offset = Math.abs(offset);
-    const hours = ~~(offset / 3600000);
-    const minutes = (offset % 3600000) / 60000;
-    return (isMinus ? "-" : "+") +
-        (0, Util_ts_1.padWithZeros)(hours, 2) + ":" +
-        (0, Util_ts_1.padWithZeros)(minutes, 2);
-}
-function dateToISOString(d, utc) {
-    if (utc) {
-        return d.toISOString();
-    }
-    else {
-        // JS Date is always local
-        const printOffset = d.kind == null ? true : d.kind === Util_ts_1.DateTimeKind.Local;
-        return (0, Util_ts_1.padWithZeros)(d.getFullYear(), 4) + "-" +
-            (0, Util_ts_1.padWithZeros)(d.getMonth() + 1, 2) + "-" +
-            (0, Util_ts_1.padWithZeros)(d.getDate(), 2) + "T" +
-            (0, Util_ts_1.padWithZeros)(d.getHours(), 2) + ":" +
-            (0, Util_ts_1.padWithZeros)(d.getMinutes(), 2) + ":" +
-            (0, Util_ts_1.padWithZeros)(d.getSeconds(), 2) + "." +
-            (0, Util_ts_1.padWithZeros)(d.getMilliseconds(), 3) +
-            (printOffset ? dateOffsetToString(d.getTimezoneOffset() * -60000) : "");
-    }
-}
-function dateToISOStringWithOffset(dateWithOffset, offset) {
-    const str = dateWithOffset.toISOString();
-    return str.substring(0, str.length - 1) + dateOffsetToString(offset);
-}
-function dateToStringWithOffset(date, format) {
-    const d = new Date(date.getTime() + (date.offset ?? 0));
-    if (typeof format !== "string") {
-        return d.toISOString().replace(/\.\d+/, "").replace(/[A-Z]|\.\d+/g, " ") + dateOffsetToString((date.offset ?? 0));
-    }
-    else if (format.length === 1) {
-        switch (format) {
-            case "D": return dateToString_D(d);
-            case "d": return dateToString_d(d);
-            case "T": return dateToString_T(toUniversalTime(d));
-            case "t": return dateToString_t(toUniversalTime(d));
-            case "O":
-            case "o": return dateToISOStringWithOffset(d, (date.offset ?? 0));
-            default: throw new Util_ts_1.Exception("Unrecognized Date print format");
-        }
-    }
-    else {
-        return dateToStringWithCustomFormat(d, format, true);
-    }
-}
-function dateToString_D(date) {
-    return longDays[dayOfWeek(date)]
-        + ", " + (0, Util_ts_1.padWithZeros)(day(date), 2)
-        + " " + longMonths[month(date) - 1]
-        + " " + year(date);
-}
-function dateToString_d(date) {
-    return (0, Util_ts_1.padWithZeros)(month(date), 2)
-        + "/" + (0, Util_ts_1.padWithZeros)(day(date), 2)
-        + "/" + year(date);
-}
-function dateToString_T(date) {
-    return (0, Util_ts_1.padWithZeros)(hour(date), 2)
-        + ":" + (0, Util_ts_1.padWithZeros)(minute(date), 2)
-        + ":" + (0, Util_ts_1.padWithZeros)(second(date), 2);
-}
-function dateToString_t(date) {
-    return (0, Util_ts_1.padWithZeros)(hour(date), 2)
-        + ":" + (0, Util_ts_1.padWithZeros)(minute(date), 2);
-}
-function dateToStringWithKind(date, format) {
-    const utc = date.kind === Util_ts_1.DateTimeKind.Utc;
-    if (typeof format !== "string") {
-        return utc ? date.toUTCString() : date.toLocaleString();
-    }
-    else if (format.length === 1) {
-        switch (format) {
-            case "D": return dateToString_D(date);
-            case "d": return dateToString_d(date);
-            case "T": return dateToString_T(date);
-            case "t": return dateToString_t(date);
-            case "O":
-            case "o":
-                return dateToISOString(date, utc);
-            default:
-                throw new Util_ts_1.Exception("Unrecognized Date print format");
-        }
-    }
-    else {
-        return dateToStringWithCustomFormat(date, format, utc);
-    }
-}
-function toString(date, format, _provider) {
-    return date.offset != null
-        ? dateToStringWithOffset(date, format)
-        : dateToStringWithKind(date, format);
-}
-function DateTime(value, kind) {
-    const d = new Date(value);
-    d.kind = (kind == null ? Util_ts_1.DateTimeKind.Unspecified : kind);
-    return d;
-}
-function fromTicks(ticks, kind) {
-    kind = kind != null ? kind : Util_ts_1.DateTimeKind.Local; // better default than Unspecified
-    let date = DateTime(ticksToUnixEpochMilliseconds(ticks), kind);
-    // Ticks are local to offset (in this case, either UTC or Local/Unknown).
-    // If kind is anything but UTC, that means that the tick number was not
-    // in utc, thus getTime() cannot return UTC, and needs to be shifted.
-    if (kind !== Util_ts_1.DateTimeKind.Utc) {
-        date = DateTime(date.getTime() - (0, Util_ts_1.dateOffset)(date), kind);
-    }
-    return date;
-}
-function fromDateTime(dateOnly, timeOnly, kind) {
-    const d = DateTime(dateOnly.getTime() + timeOnly, kind);
-    return DateTime(d.getTime() - (0, Util_ts_1.dateOffset)(d), kind);
-}
-function fromDateTimeOffset(date, kind) {
-    switch (kind) {
-        case Util_ts_1.DateTimeKind.Utc: return DateTime(date.getTime(), Util_ts_1.DateTimeKind.Utc);
-        case Util_ts_1.DateTimeKind.Local: return DateTime(date.getTime(), Util_ts_1.DateTimeKind.Local);
-        default:
-            const d = DateTime(date.getTime() + (date.offset ?? 0), kind);
-            return DateTime(d.getTime() - (0, Util_ts_1.dateOffset)(d), kind);
-    }
-}
-function getTicks(date) {
-    return unixEpochMillisecondsToTicks(date.getTime(), (0, Util_ts_1.dateOffset)(date));
-}
-function minValue() {
-    // This is "0001-01-01T00:00:00.000Z", actual JS min value is -8640000000000000
-    return DateTime(-62135596800000, Util_ts_1.DateTimeKind.Utc);
-}
-function maxValue() {
-    // This is "9999-12-31T23:59:59.999Z", actual JS max value is 8640000000000000
-    return DateTime(253402300799999, Util_ts_1.DateTimeKind.Utc);
-}
-function parseRaw(input) {
-    function fail() {
-        throw new Util_ts_1.Exception(`The string is not a valid Date: ${input}`);
-    }
-    if (input == null || input.trim() === "") {
-        fail();
-    }
-    // ISO dates without TZ are parsed as UTC. Adding time without TZ keeps them local.
-    if (input.length === 10 && input[4] === "-" && input[7] === "-") {
-        input += "T00:00:00";
-    }
-    let date = new Date(input);
-    let offset = null;
-    if (isNaN(date.getTime())) {
-        // Try to check strings JS Date cannot parse (see #1045, #1422)
-        const m = /^\s*(\d+[^\w\s:]\d+[^\w\s:]\d+)?\s*(\d+:\d+(?::\d+(?:\.\d+)?)?)?\s*([AaPp][Mm])?\s*(Z|[+-]([01]?\d):?([0-5]?\d)?)?\s*$/.exec(input);
-        if (m != null) {
-            let baseDate;
-            let timeInSeconds = 0;
-            if (m[2] != null) {
-                const timeParts = m[2].split(":");
-                const hourPart = parseInt(timeParts[0], 10);
-                timeInSeconds =
-                    hourPart * 3600 +
-                        parseInt(timeParts[1] || "0", 10) * 60 +
-                        parseFloat(timeParts[2] || "0");
-                if (m[3] != null && m[3].toUpperCase() === "PM" && hourPart < 12) {
-                    timeInSeconds += 720;
-                }
-            }
-            if (m[4] != null) { // There's an offset, parse as UTC
-                if (m[1] != null) {
-                    baseDate = new Date(m[1] + " UTC");
-                }
-                else {
-                    const d = new Date();
-                    baseDate = new Date(d.getUTCFullYear() + "/" + (d.getUTCMonth() + 1) + "/" + d.getUTCDate());
-                }
-                if (m[4] === "Z") {
-                    offset = "Z";
-                }
-                else {
-                    let offsetInMinutes = parseInt(m[5], 10) * 60 + parseInt(m[6] || "0", 10);
-                    if (m[4][0] === "-") {
-                        offsetInMinutes *= -1;
-                    }
-                    offset = offsetInMinutes;
-                    timeInSeconds -= offsetInMinutes * 60;
-                }
-            }
-            else {
-                if (m[1] != null) {
-                    baseDate = new Date(m[1]);
-                }
-                else {
-                    const d = new Date();
-                    baseDate = new Date(d.getFullYear() + "/" + (d.getMonth() + 1) + "/" + d.getDate());
-                }
-            }
-            date = new Date(baseDate.getTime() + timeInSeconds * 1000);
-            // correct for daylight savings time
-            date = new Date(date.getTime() + (date.getTimezoneOffset() - baseDate.getTimezoneOffset()) * 60000);
-        }
-        else {
-            fail();
-        }
-        // Check again the date is valid after transformations, see #2229
-        if (isNaN(date.getTime())) {
-            fail();
-        }
-    }
-    return [date, offset];
-}
-function parse(str, detectUTC = false) {
-    const [date, offset] = parseRaw(str);
-    // .NET always parses DateTime as Local if there's offset info (even "Z")
-    // Newtonsoft.Json uses UTC if the offset is "Z"
-    const kind = offset != null
-        ? (detectUTC && offset === "Z" ? Util_ts_1.DateTimeKind.Utc : Util_ts_1.DateTimeKind.Local)
-        : Util_ts_1.DateTimeKind.Unspecified;
-    return DateTime(date.getTime(), kind);
-}
-function tryParse(v, defValue) {
-    try {
-        defValue.contents = parse(v);
-        return true;
-    }
-    catch (_err) {
-        return false;
-    }
-}
-function create(year, month, day, h = 0, m = 0, s = 0, ms = 0, kind) {
-    const date = kind === Util_ts_1.DateTimeKind.Utc
-        ? new Date(Date.UTC(year, month - 1, day, h, m, s, ms))
-        : new Date(year, month - 1, day, h, m, s, ms);
-    if (year <= 99) {
-        if (kind === Util_ts_1.DateTimeKind.Utc) {
-            date.setUTCFullYear(year, month - 1, day);
-        }
-        else {
-            date.setFullYear(year, month - 1, day);
-        }
-    }
-    const dateValue = date.getTime();
-    if (isNaN(dateValue)) {
-        throw new Util_ts_1.Exception("The parameters describe an unrepresentable Date.");
-    }
-    return DateTime(dateValue, kind);
-}
-function now() {
-    return DateTime(Date.now(), Util_ts_1.DateTimeKind.Local);
-}
-function utcNow() {
-    return DateTime(Date.now(), Util_ts_1.DateTimeKind.Utc);
-}
-function today() {
-    return date(now());
-}
-function isLeapYear(year) {
-    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
-}
-function daysInMonth(year, month) {
-    return month === 2
-        ? (isLeapYear(year) ? 29 : 28)
-        : (month >= 8 ? (month % 2 === 0 ? 31 : 30) : (month % 2 === 0 ? 30 : 31));
-}
-function toUniversalTime(date) {
-    return date.kind === Util_ts_1.DateTimeKind.Utc ? date : DateTime(date.getTime(), Util_ts_1.DateTimeKind.Utc);
-}
-function toLocalTime(date) {
-    return date.kind === Util_ts_1.DateTimeKind.Local ? date : DateTime(date.getTime(), Util_ts_1.DateTimeKind.Local);
-}
-function specifyKind(d, kind) {
-    return create(year(d), month(d), day(d), hour(d), minute(d), second(d), millisecond(d), kind);
-}
-function timeOfDay(d) {
-    return hour(d) * 3600000
-        + minute(d) * 60000
-        + second(d) * 1000
-        + millisecond(d);
-}
-function date(d) {
-    return create(year(d), month(d), day(d), 0, 0, 0, 0, d.kind);
-}
-function day(d) {
-    return d.kind === Util_ts_1.DateTimeKind.Utc ? d.getUTCDate() : d.getDate();
-}
-function hour(d) {
-    return d.kind === Util_ts_1.DateTimeKind.Utc ? d.getUTCHours() : d.getHours();
-}
-function millisecond(d) {
-    return d.kind === Util_ts_1.DateTimeKind.Utc ? d.getUTCMilliseconds() : d.getMilliseconds();
-}
-function minute(d) {
-    return d.kind === Util_ts_1.DateTimeKind.Utc ? d.getUTCMinutes() : d.getMinutes();
-}
-function month(d) {
-    return (d.kind === Util_ts_1.DateTimeKind.Utc ? d.getUTCMonth() : d.getMonth()) + 1;
-}
-function second(d) {
-    return d.kind === Util_ts_1.DateTimeKind.Utc ? d.getUTCSeconds() : d.getSeconds();
-}
-function year(d) {
-    return d.kind === Util_ts_1.DateTimeKind.Utc ? d.getUTCFullYear() : d.getFullYear();
-}
-function dayOfWeek(d) {
-    return d.kind === Util_ts_1.DateTimeKind.Utc ? d.getUTCDay() : d.getDay();
-}
-function dayOfYear(d) {
-    const _year = year(d);
-    const _month = month(d);
-    let _day = day(d);
-    for (let i = 1; i < _month; i++) {
-        _day += daysInMonth(_year, i);
-    }
-    return _day;
-}
-function add(d, ts) {
-    const newDate = DateTime(d.getTime() + ts, d.kind);
-    if (d.kind !== Util_ts_1.DateTimeKind.Utc) {
-        const oldTzOffset = d.getTimezoneOffset();
-        const newTzOffset = newDate.getTimezoneOffset();
-        return oldTzOffset !== newTzOffset
-            ? DateTime(newDate.getTime() + (newTzOffset - oldTzOffset) * 60000, d.kind)
-            : newDate;
-    }
-    else {
-        return newDate;
-    }
-}
-function addDays(d, v) {
-    return add(d, v * 86400000);
-}
-function addHours(d, v) {
-    return add(d, v * 3600000);
-}
-function addMinutes(d, v) {
-    return add(d, v * 60000);
-}
-function addSeconds(d, v) {
-    return add(d, v * 1000);
-}
-function addMilliseconds(d, v) {
-    return add(d, v);
-}
-function addTicks(d, v) {
-    return add(d, (0, BigInt_ts_1.toFloat64)(v / 10000n));
-}
-function addYears(d, v) {
-    const newMonth = month(d);
-    const newYear = year(d) + v;
-    const _daysInMonth = daysInMonth(newYear, newMonth);
-    const newDay = Math.min(_daysInMonth, day(d));
-    return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);
-}
-function addMonths(d, v) {
-    let newMonth = month(d) + v;
-    let newMonth_ = 0;
-    let yearOffset = 0;
-    if (newMonth > 12) {
-        newMonth_ = newMonth % 12;
-        yearOffset = Math.floor(newMonth / 12);
-        newMonth = newMonth_;
-    }
-    else if (newMonth < 1) {
-        newMonth_ = 12 + newMonth % 12;
-        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);
-        newMonth = newMonth_;
-    }
-    const newYear = year(d) + yearOffset;
-    const _daysInMonth = daysInMonth(newYear, newMonth);
-    const newDay = Math.min(_daysInMonth, day(d));
-    return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);
-}
-function subtract(d, that) {
-    return typeof that === "number"
-        ? add(d, -that)
-        : d.getTime() - that.getTime();
-}
-function toLongDateString(d) {
-    return d.toDateString();
-}
-function toShortDateString(d) {
-    return d.toLocaleDateString();
-}
-function toLongTimeString(d) {
-    return d.toLocaleTimeString();
-}
-function toShortTimeString(d) {
-    return d.toLocaleTimeString().replace(/:\d\d(?!:)/, "");
-}
-function equals(d1, d2) {
-    return d1.getTime() === d2.getTime();
-}
-exports.compare = Util_ts_1.compareDates;
-exports.compareTo = Util_ts_1.compareDates;
-function op_Addition(x, y) {
-    return add(x, y);
-}
-function op_Subtraction(x, y) {
-    return subtract(x, y);
-}
-function isDaylightSavingTime(x) {
-    const jan = new Date(x.getFullYear(), 0, 1);
-    const jul = new Date(x.getFullYear(), 6, 1);
-    return isDST(jan.getTimezoneOffset(), jul.getTimezoneOffset(), x.getTimezoneOffset());
-}
-function isDST(janOffset, julOffset, tOffset) {
-    return Math.min(janOffset, julOffset) === tOffset;
-}
-exports.default = DateTime;
-//# sourceMappingURL=Date.js.map