@fable-org/fable-library-js 2.6.0 → 2.7.0

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: bf694309ae5dbc6bb546d9acc4d091f5e35fe330
+last_commit_released: c49d1ec5d1a491bfff65fe4bd6c71014cac9b321
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 2.7.0 - 2026-09-08
+
+### 🚀 Features
+
+* Add Temporal dates and times (opt-in) (#4759) ([3e8f56f7](https://github.com/fable-compiler/Fable/commit/3e8f56f78345fbee8a4394c5452eb212264701f9))
+
+### 🐞 Bug Fixes
+
+* *(js/ts)* Match .NET for G, E and custom numeric formats ([6fb03090](https://github.com/fable-compiler/Fable/commit/6fb03090ce328b8c5d6a36422f120dd641aefe3a))
+* *(js/ts)* Allow the E format specifier on Int64 and UInt64 ([c49d1ec5](https://github.com/fable-compiler/Fable/commit/c49d1ec5d1a491bfff65fe4bd6c71014cac9b321))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/bf694309ae5dbc6bb546d9acc4d091f5e35fe330..c49d1ec5d1a491bfff65fe4bd6c71014cac9b321)</small></strong>
+
 ## 2.6.0 - 2026-09-03
 
 ### 🚀 Features

package/DateOnlyTemporal.js

@@ -0,0 +1,146 @@
+import { dateTime as DateTime_stamp } from "./DateTimeTemporal.js";
+import { fromDate as DateTimeOffset_fromDate } from "./DateTimeOffsetTemporal.js";
+import { Exception, DateTimeKind, padWithZeros } from "./Util.js";
+export const PlainDate = Temporal.PlainDate;
+// The generic equality/comparison/hashing helpers in Util.ts dispatch at runtime
+// on .NET-style Equals/CompareTo/GetHashCode methods (with a special case for JS
+// Date, which Temporal.PlainDate cannot benefit from). Attach them so DateOnly
+// also works in generic contexts: records, tuples, erased generics, etc.
+const proto = Temporal.PlainDate.prototype;
+proto.Equals = function (other) { return this.equals(other); };
+proto.CompareTo = function (other) { return Temporal.PlainDate.compare(this, other); };
+proto.GetHashCode = function () { return dayNumber(this); };
+// Lets String.Format format this value without String.ts importing this module (see String.ts)
+proto[Symbol.for("Fable.DateTimeFormattable")] = function (format) { return toString(this, format); };
+export function create(year, month, day) {
+    return new Temporal.PlainDate(year, month, day);
+}
+export function maxValue() {
+    return new Temporal.PlainDate(9999, 12, 31);
+}
+export function minValue() {
+    return new Temporal.PlainDate(1, 1, 1);
+}
+export function dayNumber(d) {
+    return minValue().until(d).days;
+}
+export function fromDayNumber(dayNumber) {
+    return minValue().add({ days: dayNumber });
+}
+export function fromDateTime(d) {
+    // Under the Temporal representation a DateTime is a PlainDateTime (kind-agnostic wall-clock)
+    return new Temporal.PlainDate(d.year, d.month, d.day);
+}
+export function dayOfWeek(d) {
+    // Temporal: Monday = 1 ... Sunday = 7, .NET: Sunday = 0 ... Saturday = 6
+    return d.dayOfWeek % 7;
+}
+export function toDateTime(d, time, kind = DateTimeKind.Unspecified) {
+    return DateTime_stamp(d.toPlainDateTime(time), kind);
+}
+export function toDateTimeOffset(d, time, offset) {
+    return DateTimeOffset_fromDate(DateTime_stamp(d.toPlainDateTime(time), DateTimeKind.Unspecified), offset);
+}
+export function addDays(d, v) {
+    return d.add({ days: v });
+}
+export function addMonths(d, v) {
+    return d.add({ months: v });
+}
+export function addYears(d, v) {
+    return d.add({ years: v });
+}
+export function equals(x, y) {
+    return x.equals(y);
+}
+export function compare(x, y) {
+    return Temporal.PlainDate.compare(x, y);
+}
+export function hash(d) {
+    return dayNumber(d);
+}
+export function toString(d, format = "d", _provider) {
+    switch (format) {
+        case "d":
+            return `${padWithZeros(d.month, 2)}/${padWithZeros(d.day, 2)}/${padWithZeros(d.year, 4)}`;
+        case "o":
+        case "O":
+            // PlainDate.toString() is the ISO yyyy-MM-dd round-trip format
+            return d.toString();
+        default:
+            throw new Exception("Custom formats are not supported");
+    }
+}
+export function parse(str) {
+    function fail() {
+        throw new Exception(`String '${str}' was not recognized as a valid DateOnly.`);
+    }
+    // Allowed separators: . , / -
+    // TODO whitespace alone as the separator
+    //
+    // Whitespace around separators
+    //
+    // Allowed format types:
+    // yyyy/mm/dd
+    // mm/dd/yyyy
+    // mm/dd
+    // mm/yyyy
+    // yyyy/mm
+    const r = /^\s*(\d{1,4})(?:\s*[.,-\/]\s*(\d{1,2}))?\s*[.,-\/]\s*(\d{1,4})\s*$/.exec(str);
+    if (r != null) {
+        let y = 0;
+        let m = 0;
+        let d = 1;
+        if (r[2] == null) {
+            if (r[1].length < 3) {
+                if (r[3].length < 3) {
+                    // 12/30 = December 30, {CurrentYear}
+                    y = Temporal.Now.plainDateISO().year;
+                    m = +r[1];
+                    d = +r[3];
+                }
+                else {
+                    // 12/2000 = December 1, 2000
+                    m = +r[1];
+                    y = +r[3];
+                }
+            }
+            else {
+                if (r[3].length > 2)
+                    fail();
+                // 2000/12 = December 1, 2000
+                y = +r[1];
+                m = +r[3];
+            }
+        }
+        else {
+            // 2000/1/30 or 1/30/2000
+            const yearFirst = r[1].length > 2;
+            const yTmp = r[yearFirst ? 1 : 3];
+            y = +yTmp;
+            // year 0-29 is 2000-2029, 30-99 is 1930-1999
+            if (yTmp.length < 3)
+                y += y >= 30 ? 1900 : 2000;
+            m = +r[yearFirst ? 2 : 1];
+            d = +r[yearFirst ? 3 : 2];
+        }
+        if (y > 0) {
+            try {
+                return new Temporal.PlainDate(y, m, d);
+            }
+            catch {
+                return fail();
+            }
+        }
+    }
+    return fail();
+}
+export function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/DateTimeFormat.js

@@ -0,0 +1,523 @@
+/**
+ * Field-based .NET date/time formatting and lenient parsing, shared by the
+ * Temporal DateTime / DateTimeOffset representations.
+ *
+ * The formatters operate on a plain `DateInfo` (wall-clock fields), which the
+ * Temporal types expose directly (`d.year`, `d.hour`, `d.dayOfWeek % 7`, ...),
+ * so no JS-Date intermediate is needed there.
+ *
+ * Parsing is the exception. .NET accepts far more than ISO 8601 ("12/30/2009",
+ * "June 15, 2009 1:45 PM"), and the JS `Date` built-in is the only lenient date
+ * parser the platform offers — Temporal's `from` is strict ISO and rejects all of
+ * it. So `parseRaw` uses `Date` as a parsing engine and returns the instant it
+ * resolved, which callers convert into the Temporal value they need. That instant
+ * is only millisecond-precise, hence `subMillisecondTicks`: the finer digits are
+ * read straight off the input, because `Date` has already discarded them.
+ *
+ * This is a port of the equivalent logic in Date.ts / DateOffset.ts, kept
+ * separate so the Temporal modules do not depend on the JS-Date representation.
+ */
+import { Exception, DateTimeKind, padWithZeros } from "./Util.js";
+// The 7 fractional-second digits .NET works with, most significant first.
+function fractionDigits(info) {
+    return padWithZeros(info.tick, 7);
+}
+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 Exception("Invalid string format");
+            }
+        }
+        else {
+            result += currentChar;
+        }
+    }
+    if (!foundQuote) {
+        // We could not find the matching quote
+        throw new Exception(`Invalid string format could not find matching quote for ${quoteChar}`);
+    }
+    return [result, pos - beginPos + 1];
+}
+// Custom format string. `kind` decides the K/z tokens; `hostOffsetString`
+// (e.g. "+01:00") is the host-zone offset at this wall-clock, used for the
+// Local / Unspecified cases.
+export function dateToStringWithCustomFormat(info, format, kind, hostOffsetString) {
+    let cursorPos = 0;
+    let tokenLength = 0;
+    let result = "";
+    while (cursorPos < format.length) {
+        const token = format[cursorPos];
+        switch (token) {
+            case "d":
+                tokenLength = parseRepeatToken(format, cursorPos, "d");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += info.day;
+                        break;
+                    case 2:
+                        result += padWithZeros(info.day, 2);
+                        break;
+                    case 3:
+                        result += shortDays[info.dayOfWeek];
+                        break;
+                    case 4:
+                    default:
+                        result += longDays[info.dayOfWeek];
+                        break;
+                }
+                break;
+            case "f":
+                // The first `tokenLength` fractional-second digits, always padded.
+                tokenLength = parseRepeatToken(format, cursorPos, "f");
+                cursorPos += tokenLength;
+                if (tokenLength <= 7) {
+                    result += fractionDigits(info).substring(0, tokenLength);
+                }
+                else {
+                    throw "Input string was not in a correct format.";
+                }
+                break;
+            case "F":
+                // As "f", but with trailing zeros dropped — and nothing at all when the
+                // requested digits are all zero.
+                tokenLength = parseRepeatToken(format, cursorPos, "F");
+                cursorPos += tokenLength;
+                if (tokenLength <= 7) {
+                    result += fractionDigits(info).substring(0, tokenLength).replace(/0+$/, "");
+                }
+                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 = info.hour % 12;
+                        result += h1Value ? h1Value : 12;
+                        break;
+                    case 2:
+                    default:
+                        const h2Value = info.hour % 12;
+                        result += padWithZeros(h2Value ? h2Value : 12, 2);
+                        break;
+                }
+                break;
+            case "H":
+                tokenLength = parseRepeatToken(format, cursorPos, "H");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += info.hour;
+                        break;
+                    case 2:
+                    default:
+                        result += padWithZeros(info.hour, 2);
+                        break;
+                }
+                break;
+            case "K":
+                tokenLength = parseRepeatToken(format, cursorPos, "K");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        switch (kind) {
+                            case DateTimeKind.Utc:
+                                result += "Z";
+                                break;
+                            case DateTimeKind.Local:
+                                result += hostOffsetString;
+                                break;
+                            case DateTimeKind.Unspecified:
+                                break;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "m":
+                tokenLength = parseRepeatToken(format, cursorPos, "m");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += info.minute;
+                        break;
+                    case 2:
+                    default:
+                        result += padWithZeros(info.minute, 2);
+                        break;
+                }
+                break;
+            case "M":
+                tokenLength = parseRepeatToken(format, cursorPos, "M");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += info.month;
+                        break;
+                    case 2:
+                        result += padWithZeros(info.month, 2);
+                        break;
+                    case 3:
+                        result += shortMonths[info.month - 1];
+                        break;
+                    case 4:
+                    default:
+                        result += longMonths[info.month - 1];
+                        break;
+                }
+                break;
+            case "s":
+                tokenLength = parseRepeatToken(format, cursorPos, "s");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += info.second;
+                        break;
+                    case 2:
+                    default:
+                        result += padWithZeros(info.second, 2);
+                        break;
+                }
+                break;
+            case "t":
+                tokenLength = parseRepeatToken(format, cursorPos, "t");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += info.hour < 12 ? "A" : "P";
+                        break;
+                    case 2:
+                    default:
+                        result += info.hour < 12 ? "AM" : "PM";
+                        break;
+                }
+                break;
+            case "y":
+                tokenLength = parseRepeatToken(format, cursorPos, "y");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += info.year % 100;
+                        break;
+                    case 2:
+                        result += padWithZeros(info.year % 100, 2);
+                        break;
+                    default:
+                        result += padWithZeros(info.year, tokenLength);
+                        break;
+                }
+                break;
+            case "z":
+                tokenLength = parseRepeatToken(format, cursorPos, "z");
+                cursorPos += tokenLength;
+                const utcOffsetText = kind === DateTimeKind.Utc ? "+00:00" : hostOffsetString;
+                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}${padWithZeros(hours, 2)}`;
+                        break;
+                    default:
+                        result += `${sign}${padWithZeros(hours, 2)}:${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(info, String.fromCharCode(nextChar), kind, hostOffsetString);
+                }
+                else {
+                    throw new Exception("Invalid format string");
+                }
+                break;
+            case "\\":
+                const nextChar2 = parseNextChar(format, cursorPos);
+                if (nextChar2 >= 0) {
+                    cursorPos += 2;
+                    result += String.fromCharCode(nextChar2);
+                }
+                else {
+                    throw new Exception("Invalid format string");
+                }
+                break;
+            default:
+                cursorPos++;
+                result += token;
+                break;
+        }
+    }
+    return result;
+}
+// --- Standard single-letter format building blocks (InvariantCulture) ---
+export function dateToString_D(info) {
+    return longDays[info.dayOfWeek]
+        + ", " + padWithZeros(info.day, 2)
+        + " " + longMonths[info.month - 1]
+        + " " + info.year;
+}
+export function dateToString_d(info) {
+    return padWithZeros(info.month, 2)
+        + "/" + padWithZeros(info.day, 2)
+        + "/" + info.year;
+}
+export function dateToString_T(info) {
+    return padWithZeros(info.hour, 2)
+        + ":" + padWithZeros(info.minute, 2)
+        + ":" + padWithZeros(info.second, 2);
+}
+export function dateToString_t(info) {
+    return padWithZeros(info.hour, 2)
+        + ":" + padWithZeros(info.minute, 2);
+}
+// RFC 1123: "Thu, 01 Jan 2009 00:00:00 GMT". `info` must already be UTC.
+export function dateToString_R(info) {
+    return shortDays[info.dayOfWeek] + ", "
+        + padWithZeros(info.day, 2) + " "
+        + shortMonths[info.month - 1] + " "
+        + info.year + " "
+        + padWithZeros(info.hour, 2) + ":"
+        + padWithZeros(info.minute, 2) + ":"
+        + padWithZeros(info.second, 2) + " GMT";
+}
+// Universal sortable: "2009-06-15 13:45:30Z". `info` must already be UTC.
+export function dateToString_u(info) {
+    return padWithZeros(info.year, 4) + "-"
+        + padWithZeros(info.month, 2) + "-"
+        + padWithZeros(info.day, 2) + " "
+        + padWithZeros(info.hour, 2) + ":"
+        + padWithZeros(info.minute, 2) + ":"
+        + padWithZeros(info.second, 2) + "Z";
+}
+// Month/day (InvariantCulture "MMMM dd"): "June 15"
+export function dateToString_M(info) {
+    return longMonths[info.month - 1] + " " + padWithZeros(info.day, 2);
+}
+// Year/month (InvariantCulture "yyyy MMMM"): "2009 June"
+export function dateToString_Y(info) {
+    return info.year + " " + longMonths[info.month - 1];
+}
+// .NET's standard date/time format specifiers, InvariantCulture. Anything that is
+// not a single recognised letter is treated as a custom format string.
+export function dateToString(ctx, format) {
+    const info = ctx.info;
+    if (typeof format !== "string") {
+        return dateToString_d(info) + " " + dateToString_T(info) + ctx.defaultSuffix;
+    }
+    if (format.length === 1) {
+        switch (format) {
+            case "D": return dateToString_D(info);
+            case "d": return dateToString_d(info);
+            case "F": return dateToString_D(info) + " " + dateToString_T(info);
+            case "f": return dateToString_D(info) + " " + dateToString_t(info);
+            case "G": return dateToString_d(info) + " " + dateToString_T(info);
+            case "g": return dateToString_d(info) + " " + dateToString_t(info);
+            case "M":
+            case "m": return dateToString_M(info);
+            case "O":
+            case "o": return ctx.roundTrip();
+            case "R":
+            case "r": return dateToString_R(ctx.utcInfo());
+            case "s": return ctx.sortable();
+            case "T": return dateToString_T(info);
+            case "t": return dateToString_t(info);
+            case "u": return dateToString_u(ctx.utcInfo());
+            case "U": {
+                const utc = ctx.utcInfo();
+                return dateToString_D(utc) + " " + dateToString_T(utc);
+            }
+            case "Y":
+            case "y": return dateToString_Y(info);
+            default: throw new Exception("Unrecognized Date print format");
+        }
+    }
+    return dateToStringWithCustomFormat(info, format, ctx.kind, ctx.hostOffsetString());
+}
+// The only date words .NET's invariant parser recognises: month names, weekday names,
+// meridiem designators and zone markers (plus the ISO "T" separator). Anything else is
+// rejected. Used to reject JS-permissive inputs (see `parseRaw`).
+const recognizedDateWords = new Set([
+    "january", "february", "march", "april", "may", "june",
+    "july", "august", "september", "october", "november", "december",
+    "jan", "feb", "mar", "apr", "jun", "jul", "aug", "sep", "sept", "oct", "nov", "dec",
+    "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday",
+    "mon", "tue", "wed", "thu", "fri", "sat", "sun",
+    "am", "pm", "gmt", "utc", "ut", "t", "z",
+]);
+// The ticks below the millisecond (0..9999) written in the seconds fraction of
+// `input`, e.g. "…:30.6175425" -> 5425.
+//
+// `parseRaw` resolves the instant through the JS `Date` built-in, which is
+// millisecond-precise, so those digits would otherwise be lost. Anchoring on
+// ":ss." keeps date separators (as in "15.06.2009") from matching. Digits past
+// the 7th are truncated, matching how TimeOnly/TimeSpan parsing treats them.
+export function subMillisecondTicks(input) {
+    const m = /:\d{1,2}\.(\d+)/.exec(input);
+    return m == null ? 0 : +m[1].padEnd(7, "0").substring(3, 7);
+}
+// A trailing UTC designator, if the input carries one. The JS `Date` built-in
+// applies the offset but does not report whether there was one, and callers need
+// that: .NET gives a parsed value Kind=Local when an offset is present and
+// Kind=Unspecified when it is not.
+//
+// The offset is only recognised after a time, so that the trailing "-11" of a
+// date like "2014-09-11" is not mistaken for one.
+function detectOffset(input) {
+    const m = /\d\d:\d\d(?::\d\d)?(?:\.\d+)?\s*(Z|[+-]\d\d:?(?:\d\d)?)\s*$/i.exec(input);
+    if (m == null) {
+        return null;
+    }
+    const designator = m[1];
+    if (designator.toUpperCase() === "Z") {
+        return "Z";
+    }
+    const digits = designator.substring(1).replace(":", "");
+    const minutes = +digits.substring(0, 2) * 60 + (digits.length > 2 ? +digits.substring(2) : 0);
+    return designator[0] === "-" ? -minutes : minutes;
+}
+// Lenient .NET-compatible parse. Returns a JS Date (the parsed instant) and the
+// detected offset, if any. Callers read the wall-clock fields and build the
+// appropriate Temporal value.
+export function parseRaw(input) {
+    function fail() {
+        throw new Exception(`The string is not a valid Date: ${input}`);
+    }
+    if (input == null || input.trim() === "") {
+        fail();
+    }
+    if ((input.match(/[a-z]+/gi) ?? []).some(word => !recognizedDateWords.has(word.toLowerCase()))) {
+        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 = detectOffset(input);
+    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 += 12 * 3600;
+                }
+                else if (m[3] != null && m[3].toUpperCase() === "AM" && hourPart === 12) {
+                    timeInSeconds -= 12 * 3600;
+                }
+            }
+            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];
+}