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

package/DateTimeOffsetTemporal.js

@@ -0,0 +1,283 @@
+/**
+ * DateTimeOffset as an offset-only Temporal.ZonedDateTime.
+ *
+ * .NET DateTimeOffset is a wall-clock date+time plus an explicit UTC offset (a
+ * TimeSpan of whole minutes). A ZonedDateTime whose time zone is a fixed offset
+ * (e.g. "-08:00") carries the wall-clock, the offset, and the absolute instant
+ * natively — so there is no extra metadata to stamp and no re-stamping after
+ * operations (arithmetic returns a ZonedDateTime that keeps the offset).
+ *
+ * The offset is exchanged with the rest of the runtime as a TimeSpan (Temporal
+ * .Duration), matching how .NET types it. Equality/comparison are by instant
+ * (offset-independent), matching .NET '=='; EqualsExact also compares the offset.
+ *
+ * Formatting and parsing run on the Temporal value's own fields (see
+ * DateTimeFormat.ts) rather than through a JS Date, which would truncate every
+ * value to milliseconds.
+ */
+import { fromFloat64 } from "./BigInt.js";
+import { Exception, DateTimeKind, padWithZeros } from "./Util.js";
+import { fromTicks as TimeSpan_fromTicks, fromUnits as TimeSpan_fromUnits, totalNanoseconds as TimeSpan_totalNanoseconds, } from "./TimeSpanTemporal.js";
+import { dateTime, create as createDateTime, getTicks as DateTime_getTicks } from "./DateTimeTemporal.js";
+import * as Format from "./DateTimeFormat.js";
+export const ZonedDateTime = Temporal.ZonedDateTime;
+// Generic equality/comparison/hashing dispatch (Util.ts) uses .NET-style methods.
+const proto = Temporal.ZonedDateTime.prototype;
+proto.Equals = function (other) { return equals(this, other); };
+proto.CompareTo = function (other) { return compare(this, other); };
+proto.GetHashCode = function () { return hash(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); };
+const nsPerMinute = 60000000000n;
+// Nanoseconds between the Unix epoch (1970-01-01) and DateTime.MinValue (0001-01-01)
+const epochToMinValueNs = 62135596800000n * 1000000n;
+function hostTimeZone() {
+    return Temporal.Now.timeZoneId();
+}
+// .NET DateTimeOffset has 100ns (tick) precision; Temporal instants are
+// nanosecond-precise. Floors, so the tick count from year 1 is floored too.
+function truncateToTicks(epochNs) {
+    const remainder = epochNs % 100n;
+    return remainder >= 0n ? epochNs - remainder : epochNs - remainder - 100n;
+}
+function checkOffsetInRange(offsetNs) {
+    if (offsetNs % nsPerMinute !== 0n) {
+        throw new Exception("Offset must be specified in whole minutes.");
+    }
+    if (offsetNs > 14n * 60n * nsPerMinute || offsetNs < -14n * 60n * nsPerMinute) {
+        throw new Exception("Offset must be within plus or minus 14 hours.");
+    }
+}
+function offsetNanosecondsToZoneString(offsetNs) {
+    const sign = offsetNs < 0n ? "-" : "+";
+    const abs = offsetNs < 0n ? -offsetNs : offsetNs;
+    const totalMinutes = Number(abs / nsPerMinute);
+    return `${sign}${padWithZeros(Math.trunc(totalMinutes / 60), 2)}:${padWithZeros(totalMinutes % 60, 2)}`;
+}
+function offsetToNanoseconds(offset) {
+    return TimeSpan_totalNanoseconds(offset);
+}
+function fromEpoch(epochNs, offsetNs = 0n) {
+    if (offsetNs === 0n)
+        return new Temporal.ZonedDateTime(epochNs, "UTC");
+    checkOffsetInRange(offsetNs);
+    return new Temporal.ZonedDateTime(epochNs, offsetNanosecondsToZoneString(offsetNs));
+}
+export function offset(d) {
+    return TimeSpan_fromTicks(BigInt(d.offsetNanoseconds) / 100n);
+}
+export function create(year, month, day, h, m, s, ms, offset) {
+    // Overload without milliseconds: the 7th argument is the offset
+    if (offset == null) {
+        offset = ms;
+        ms = 0;
+    }
+    const offsetNs = offsetToNanoseconds(offset);
+    checkOffsetInRange(offsetNs);
+    return Temporal.ZonedDateTime.from({
+        year, month, day, hour: h, minute: m, second: s, millisecond: ms,
+        timeZone: offsetNanosecondsToZoneString(offsetNs),
+    });
+}
+// Offset (ns) of the host time zone for a given wall-clock, DST-aware. Resolved
+// through Temporal rather than `new Date(year, ...)`, which maps years 0-99 into
+// 1900-1999 and would pick that era's rules.
+function hostOffsetNanoseconds(d) {
+    return BigInt(d.toZonedDateTime(hostTimeZone()).offsetNanoseconds);
+}
+export function fromDate(date, offset) {
+    const kind = date.kind ?? DateTimeKind.Unspecified;
+    let offsetNs;
+    switch (kind) {
+        case DateTimeKind.Utc:
+            if (offset != null && offsetToNanoseconds(offset) !== 0n) {
+                throw new Exception("The UTC Offset for Utc DateTime instances must be 0.");
+            }
+            offsetNs = 0n;
+            break;
+        case DateTimeKind.Local:
+            offsetNs = hostOffsetNanoseconds(date);
+            if (offset != null && offsetToNanoseconds(offset) !== offsetNs) {
+                throw new Exception("The UTC Offset of the local dateTime parameter does not match the offset argument.");
+            }
+            break;
+        default:
+            offsetNs = offset != null ? offsetToNanoseconds(offset) : hostOffsetNanoseconds(date);
+            break;
+    }
+    checkOffsetInRange(offsetNs);
+    return Temporal.ZonedDateTime.from({
+        year: date.year, month: date.month, day: date.day,
+        hour: date.hour, minute: date.minute, second: date.second,
+        millisecond: date.millisecond, microsecond: date.microsecond, nanosecond: date.nanosecond,
+        timeZone: offsetNanosecondsToZoneString(offsetNs),
+    });
+}
+export function fromTicks(ticks, offset) {
+    const offsetNs = offsetToNanoseconds(offset);
+    // ticks are the local wall-clock ticks; the instant is that minus the offset
+    const localNs = BigInt(ticks) * 100n - epochToMinValueNs;
+    return fromEpoch(localNs - offsetNs, offsetNs);
+}
+export function fromUnixTimeMilliseconds(ms) {
+    return fromEpoch(BigInt(ms) * 1000000n);
+}
+export function fromUnixTimeSeconds(seconds) {
+    return fromEpoch(BigInt(seconds) * 1000000000n);
+}
+export function minValue() {
+    return fromEpoch(-epochToMinValueNs);
+}
+export function maxValue() {
+    // 9999-12-31T23:59:59.9999999 UTC
+    return fromEpoch(253402300799999999900n, 0n);
+}
+export function dayOfWeek(d) {
+    return d.dayOfWeek % 7;
+}
+export function timeOfDay(d) {
+    // Elapsed since midnight (local wall-clock). DateTimeOffset values are tick-aligned, so this is too.
+    return d.startOfDay().until(d);
+}
+export function date(d) {
+    return createDateTime(d.year, d.month, d.day, 0, 0, 0, 0, DateTimeKind.Unspecified);
+}
+export function dateTimeProp(d) {
+    return dateTime(d.toPlainDateTime(), DateTimeKind.Unspecified);
+}
+export function toUniversalTime(d) {
+    return fromEpoch(d.epochNanoseconds);
+}
+export function toLocalTime(d) {
+    const local = d.withTimeZone(hostTimeZone());
+    return fromEpoch(local.epochNanoseconds, BigInt(local.offsetNanoseconds));
+}
+export function utcDateTime(d) {
+    return dateTime(d.withTimeZone("UTC").toPlainDateTime(), DateTimeKind.Utc);
+}
+export function localDateTime(d) {
+    return dateTime(d.withTimeZone(hostTimeZone()).toPlainDateTime(), DateTimeKind.Local);
+}
+export function add(d, ts) {
+    return d.add(ts);
+}
+export function addYears(d, v) {
+    return d.add({ years: v });
+}
+export function addMonths(d, v) {
+    return d.add({ months: v });
+}
+export function addDays(d, v) {
+    return d.add(TimeSpan_fromUnits(v, "days"));
+}
+export function addHours(d, v) {
+    return d.add(TimeSpan_fromUnits(v, "hours"));
+}
+export function addMinutes(d, v) {
+    return d.add(TimeSpan_fromUnits(v, "minutes"));
+}
+export function addSeconds(d, v) {
+    return d.add(TimeSpan_fromUnits(v, "seconds"));
+}
+export function addMilliseconds(d, v) {
+    return d.add(TimeSpan_fromUnits(v, "milliseconds"));
+}
+export function addTicks(d, v) {
+    return d.add(TimeSpan_fromTicks(v));
+}
+// Split rather than returning a union — see the note in DateTimeTemporal.ts.
+export function subtractDate(d, that) {
+    return TimeSpan_fromTicks((d.epochNanoseconds - that.epochNanoseconds) / 100n); // instant difference
+}
+export function subtractTimeSpan(d, ts) {
+    return d.subtract(ts);
+}
+export function equals(d1, d2) {
+    return d1.epochNanoseconds === d2.epochNanoseconds;
+}
+export function equalsExact(d1, d2) {
+    return d1.epochNanoseconds === d2.epochNanoseconds && d1.offsetNanoseconds === d2.offsetNanoseconds;
+}
+export function compare(d1, d2) {
+    const a = d1.epochNanoseconds, b = d2.epochNanoseconds;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+export const compareTo = compare;
+export function op_Addition(x, y) {
+    return add(x, y);
+}
+export function hash(d) {
+    return Number(d.epochNanoseconds % 2147483647n);
+}
+export function toOffset(d, offset) {
+    return fromEpoch(d.epochNanoseconds, offsetToNanoseconds(offset));
+}
+export function getUtcTicks(d) {
+    return DateTime_getTicks(utcDateTime(d));
+}
+export function getTicks(d) {
+    return DateTime_getTicks(dateTimeProp(d));
+}
+export function toUnixTimeMilliseconds(d) {
+    return fromFloat64(d.epochMilliseconds);
+}
+export function toUnixTimeSeconds(d) {
+    return fromFloat64(Math.floor(d.epochMilliseconds / 1000));
+}
+export function now() {
+    const z = Temporal.Now.zonedDateTimeISO(hostTimeZone());
+    return fromEpoch(truncateToTicks(z.epochNanoseconds), BigInt(z.offsetNanoseconds));
+}
+export function utcNow() {
+    return fromEpoch(truncateToTicks(Temporal.Now.instant().epochNanoseconds));
+}
+// --- Formatting and parsing ---
+// Wall-clock fields for the formatter, with the sub-second component in .NET
+// ticks so "O" and the f/F specifiers can print all 7 digits.
+function toDateInfo(z) {
+    return {
+        year: z.year,
+        month: z.month,
+        day: z.day,
+        hour: z.hour,
+        minute: z.minute,
+        second: z.second,
+        tick: z.millisecond * 10000 + z.microsecond * 10 + Math.trunc(z.nanosecond / 100),
+        dayOfWeek: z.dayOfWeek % 7,
+    };
+}
+export function toString(d, format, _provider) {
+    const offsetString = () => offsetNanosecondsToZoneString(BigInt(d.offsetNanoseconds));
+    return Format.dateToString({
+        info: toDateInfo(d),
+        utcInfo: () => toDateInfo(d.withTimeZone("UTC")),
+        // A fixed-offset zone renders as .NET's "O" exactly: ISO wall-clock plus
+        // the numeric offset, with no [zone] annotation.
+        roundTrip: () => d.toString({ fractionalSecondDigits: 7, timeZoneName: "never" }),
+        sortable: () => d.toPlainDateTime().toString({ smallestUnit: "second" }),
+        defaultSuffix: " " + offsetString(),
+        // K/z print the value's own offset, never the host zone's, so Local is
+        // passed as the kind and that offset stands in for the host one.
+        kind: DateTimeKind.Local,
+        hostOffsetString: offsetString,
+    }, format);
+}
+export function parse(str) {
+    const [parsed, offsetMatch] = Format.parseRaw(str);
+    // parseRaw resolves the instant through JS Date, which truncates at the
+    // millisecond, so the digits below that are recovered from the input separately.
+    const epochNs = BigInt(parsed.getTime()) * 1000000n + BigInt(Format.subMillisecondTicks(str)) * 100n;
+    const offsetNs = offsetMatch == null
+        ? BigInt(new Temporal.Instant(epochNs).toZonedDateTimeISO(hostTimeZone()).offsetNanoseconds)
+        : (offsetMatch === "Z" ? 0n : BigInt(offsetMatch) * nsPerMinute);
+    return fromEpoch(epochNs, offsetNs);
+}
+export function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/DateTimeTemporal.js

@@ -0,0 +1,243 @@
+/**
+ * DateTime as an extended Temporal.PlainDateTime.
+ *
+ * .NET DateTime is a wall-clock date+time (no offset) plus a Kind (Utc | Local |
+ * Unspecified) that is metadata only. PlainDateTime models the wall-clock exactly
+ * and, unlike the JS Date representation, is tick (100ns) precise and DST-agnostic
+ * for arithmetic — which matches .NET, where DateTime math operates on the raw
+ * wall-clock ticks.
+ *
+ * Kind has no Temporal home, so it is attached to the instance as a `kind` property
+ * (Temporal objects are extensible). Because Temporal operations return fresh,
+ * un-stamped instances, every operation must funnel through `dateTime(...)` to
+ * re-stamp the kind.
+ *
+ * Formatting, parsing and time-zone conversion are done on the Temporal value
+ * itself (see DateTimeFormat.ts), never by round-tripping through a JS Date —
+ * that would silently truncate every value to milliseconds. The one exception is
+ * the four ToLong/ShortDate/TimeString members, which are host-locale display
+ * strings with no .NET-defined layout and no sub-second component.
+ */
+import { toInt64 } from "./BigInt.js";
+import { DateTimeKind } from "./Util.js";
+import { fromTicks as TimeSpan_fromTicks, fromUnits as TimeSpan_fromUnits, totalNanoseconds as TimeSpan_totalNanoseconds, } from "./TimeSpanTemporal.js";
+import * as Format from "./DateTimeFormat.js";
+export const PlainDateTime = Temporal.PlainDateTime;
+// Generic equality/comparison/hashing dispatch (Util.ts) uses .NET-style methods.
+const proto = Temporal.PlainDateTime.prototype;
+proto.Equals = function (other) { return Temporal.PlainDateTime.compare(this, other) === 0; };
+proto.CompareTo = function (other) { return Temporal.PlainDateTime.compare(this, other); };
+proto.GetHashCode = function () { return hash(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); };
+const minDateTime = new Temporal.PlainDateTime(1, 1, 1);
+export function getKind(value) {
+    return value.kind ?? DateTimeKind.Unspecified;
+}
+export function dateTime(value, kind = DateTimeKind.Unspecified) {
+    const d = value;
+    d.kind = kind;
+    return d;
+}
+// `dateTime` stamps in place, so anything handing out a value derived from a
+// shared instance (a module constant, or the argument of SpecifyKind) has to
+// copy first, or it would mutate the caller's value.
+function copy(d) {
+    return new Temporal.PlainDateTime(d.year, d.month, d.day, d.hour, d.minute, d.second, d.millisecond, d.microsecond, d.nanosecond);
+}
+function hostTimeZone() {
+    return Temporal.Now.timeZoneId();
+}
+// Host-zone offset at this wall-clock, e.g. "+01:00". Unlike building a JS Date
+// from the fields, this is correct for years 0-99 (which JS maps to 1900-1999).
+function hostOffsetString(d) {
+    return d.toZonedDateTime(hostTimeZone()).offset;
+}
+// Wall-clock fields for the formatter. The sub-second component is carried in
+// .NET ticks so that "O" and the f/F specifiers can print all 7 digits.
+function toDateInfo(d) {
+    return {
+        year: d.year,
+        month: d.month,
+        day: d.day,
+        hour: d.hour,
+        minute: d.minute,
+        second: d.second,
+        tick: d.millisecond * 10000 + d.microsecond * 10 + Math.trunc(d.nanosecond / 100),
+        dayOfWeek: dayOfWeek(d),
+    };
+}
+// Display-only bridge for the host-locale strings below. Sub-second precision is
+// irrelevant to all four, but years 0-99 still need correcting.
+function toJsDate(d) {
+    const jsDate = new Date(d.year, d.month - 1, d.day, d.hour, d.minute, d.second, d.millisecond);
+    jsDate.setFullYear(d.year, d.month - 1, d.day);
+    return jsDate;
+}
+export function create(year, month, day, h = 0, m = 0, s = 0, ms = 0, kind) {
+    return dateTime(new Temporal.PlainDateTime(year, month, day, h, m, s, ms), kind);
+}
+export function fromTicks(ticks, kind) {
+    return dateTime(minDateTime.add(TimeSpan_fromTicks(ticks)), kind);
+}
+export function getTicks(date) {
+    return toInt64(TimeSpan_totalNanoseconds(minDateTime.until(date, { largestUnit: "day" })) / 100n);
+}
+export function minValue() {
+    return dateTime(copy(minDateTime), DateTimeKind.Unspecified);
+}
+export function maxValue() {
+    return dateTime(new Temporal.PlainDateTime(9999, 12, 31, 23, 59, 59, 999, 999, 900), DateTimeKind.Unspecified);
+}
+// .NET DateTime has 100ns (tick) precision; Temporal.Now is nanosecond-precise.
+function truncateToTicks(d) {
+    return d.round({ smallestUnit: "nanosecond", roundingIncrement: 100, roundingMode: "trunc" });
+}
+export function now() {
+    return dateTime(truncateToTicks(Temporal.Now.plainDateTimeISO()), DateTimeKind.Local);
+}
+export function utcNow() {
+    return dateTime(truncateToTicks(Temporal.Now.plainDateTimeISO("UTC")), DateTimeKind.Utc);
+}
+export function today() {
+    return date(now());
+}
+export function specifyKind(d, kind) {
+    // Kind is metadata: every tick of the wall-clock is preserved.
+    return dateTime(copy(d), kind);
+}
+export function dayOfWeek(d) {
+    // Temporal: Monday = 1 ... Sunday = 7, .NET: Sunday = 0 ... Saturday = 6
+    return d.dayOfWeek % 7;
+}
+export function date(d) {
+    return dateTime(d.with({ hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }), getKind(d));
+}
+export function timeOfDay(d) {
+    // Elapsed since midnight. DateTime values are tick-aligned, so this is too.
+    return d.with({ hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }).until(d);
+}
+export function add(d, ts) {
+    return dateTime(d.add(ts), getKind(d));
+}
+export function addYears(d, v) {
+    return dateTime(d.add({ years: v }), getKind(d));
+}
+export function addMonths(d, v) {
+    return dateTime(d.add({ months: v }), getKind(d));
+}
+export function addDays(d, v) {
+    return dateTime(d.add(TimeSpan_fromUnits(v, "days")), getKind(d));
+}
+export function addHours(d, v) {
+    return dateTime(d.add(TimeSpan_fromUnits(v, "hours")), getKind(d));
+}
+export function addMinutes(d, v) {
+    return dateTime(d.add(TimeSpan_fromUnits(v, "minutes")), getKind(d));
+}
+export function addSeconds(d, v) {
+    return dateTime(d.add(TimeSpan_fromUnits(v, "seconds")), getKind(d));
+}
+export function addMilliseconds(d, v) {
+    return dateTime(d.add(TimeSpan_fromUnits(v, "milliseconds")), getKind(d));
+}
+export function addTicks(d, v) {
+    return dateTime(d.add(TimeSpan_fromTicks(v)), getKind(d));
+}
+export function subtractDate(d, that) {
+    return that.until(d, { largestUnit: "day" });
+}
+export function subtractTimeSpan(d, ts) {
+    return dateTime(d.subtract(ts), getKind(d));
+}
+export function equals(d1, d2) {
+    return Temporal.PlainDateTime.compare(d1, d2) === 0;
+}
+export function compare(d1, d2) {
+    return Temporal.PlainDateTime.compare(d1, d2);
+}
+export const compareTo = compare;
+export function op_Addition(x, y) {
+    return add(x, y);
+}
+export function hash(d) {
+    return Number(getTicks(d) % 2147483647n);
+}
+export function isLeapYear(year) {
+    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+export function daysInMonth(year, month) {
+    return month === 2
+        ? (isLeapYear(year) ? 29 : 28)
+        : (month >= 8 ? (month % 2 === 0 ? 31 : 30) : (month % 2 === 0 ? 30 : 31));
+}
+// --- Host time zone ---
+export function toUniversalTime(d) {
+    // .NET reads an Unspecified value as local time here.
+    return getKind(d) === DateTimeKind.Utc
+        ? d
+        : dateTime(d.toZonedDateTime(hostTimeZone()).withTimeZone("UTC").toPlainDateTime(), DateTimeKind.Utc);
+}
+export function toLocalTime(d) {
+    // .NET reads an Unspecified value as UTC here — the mirror image of the above.
+    return getKind(d) === DateTimeKind.Local
+        ? d
+        : dateTime(d.toZonedDateTime("UTC").withTimeZone(hostTimeZone()).toPlainDateTime(), DateTimeKind.Local);
+}
+export function isDaylightSavingTime(d) {
+    const tz = hostTimeZone();
+    const offsetAt = (month) => new Temporal.PlainDateTime(d.year, month, 1).toZonedDateTime(tz).offsetNanoseconds;
+    // The larger of the two mid-season offsets is the daylight-saving one.
+    return Math.max(offsetAt(1), offsetAt(7)) === d.toZonedDateTime(tz).offsetNanoseconds;
+}
+// --- Host-locale display strings (no .NET-defined layout) ---
+export function toLongDateString(d) {
+    return toJsDate(d).toDateString();
+}
+export function toShortDateString(d) {
+    return toJsDate(d).toLocaleDateString();
+}
+export function toLongTimeString(d) {
+    return toJsDate(d).toLocaleTimeString();
+}
+export function toShortTimeString(d) {
+    return toJsDate(d).toLocaleTimeString().replace(/:\d\d(?!:)/, "");
+}
+// --- Formatting and parsing ---
+export function toString(d, format, _provider) {
+    const kind = getKind(d);
+    return Format.dateToString({
+        info: toDateInfo(d),
+        utcInfo: () => toDateInfo(toUniversalTime(d)),
+        // An Unspecified DateTime prints no zone at all, which is what makes "O"
+        // round-trip it back to Unspecified.
+        roundTrip: () => d.toString({ fractionalSecondDigits: 7 })
+            + (kind === DateTimeKind.Utc ? "Z" : kind === DateTimeKind.Local ? hostOffsetString(d) : ""),
+        sortable: () => d.toString({ smallestUnit: "second" }),
+        defaultSuffix: "",
+        kind,
+        hostOffsetString: () => hostOffsetString(d),
+    }, format);
+}
+export function parse(str, detectUTC = false) {
+    const [parsed, offset] = Format.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" ? DateTimeKind.Utc : DateTimeKind.Local)
+        : DateTimeKind.Unspecified;
+    // parseRaw resolves the instant through JS Date, which truncates at the
+    // millisecond, so the digits below that are recovered from the input separately.
+    const epochNs = BigInt(parsed.getTime()) * 1000000n + BigInt(Format.subMillisecondTicks(str)) * 100n;
+    const zone = kind === DateTimeKind.Utc ? "UTC" : hostTimeZone();
+    return dateTime(new Temporal.Instant(epochNs).toZonedDateTimeISO(zone).toPlainDateTime(), kind);
+}
+export function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/Guid.js

@@ -66,7 +66,9 @@ export function newGuid() {
 }
 // RFC 9562 UUID v7
 export function createVersion7(timestamp) {
-    const ms = timestamp != null ? timestamp.getTime() : Date.now();
+    // A number/bigint timestamp is Unix milliseconds (used by the Temporal representation,
+    // whose DateTimeOffset is not a JS Date); a Date uses getTime().
+    const ms = timestamp == null ? Date.now() : typeof timestamp === "object" ? timestamp.getTime() : Number(timestamp);
     // 48-bit timestamp as hex
     const msHex = Math.floor(ms).toString(16).padStart(12, "0");
     // random bits

package/Numeric.js

@@ -28,6 +28,18 @@ export function multiply(x, y) {
         return x[symbol]().multiply(y);
     }
 }
+export function divide(x, y) {
+    if (typeof x === "number") {
+        return x / y;
+    }
+    else if (typeof x === "bigint") {
+        // Keep the fractional part so the caller can round it like .NET does
+        return Number(x) / y;
+    }
+    else {
+        return x[symbol]().multiply(1 / y);
+    }
+}
 export function toFixed(x, dp) {
     if (typeof x === "number") {
         return x.toFixed(dp);
@@ -50,12 +62,37 @@ export function toPrecision(x, sd) {
         return x[symbol]().toPrecision(sd);
     }
 }
+// A bigint can hold more significant digits than a double, so the mantissa is rounded on the
+// decimal digits themselves instead of going through Number
+function bigintToExponential(x, dp) {
+    const sign = x < 0n ? "-" : "";
+    let digits = (x < 0n ? -x : x).toString();
+    if (x === 0n) {
+        return sign + (dp ? "0." + "0".repeat(dp) : "0") + "e+0";
+    }
+    dp = dp ?? digits.length - 1;
+    let exponent = digits.length - 1;
+    if (digits.length > dp + 1) {
+        // .NET rounds the discarded digits away from zero
+        const roundUp = digits.charCodeAt(dp + 1) >= 53;
+        digits = (BigInt(digits.slice(0, dp + 1)) + (roundUp ? 1n : 0n)).toString();
+        if (digits.length > dp + 1) {
+            digits = digits.slice(0, dp + 1);
+            exponent += 1;
+        }
+    }
+    else {
+        digits = digits.padEnd(dp + 1, "0");
+    }
+    const mantissa = dp > 0 ? digits[0] + "." + digits.slice(1) : digits[0];
+    return sign + mantissa + "e+" + exponent;
+}
 export function toExponential(x, dp) {
     if (typeof x === "number") {
         return x.toExponential(dp);
     }
     else if (typeof x === "bigint") {
-        return x;
+        return bigintToExponential(x, dp);
     }
     else {
         return x[symbol]().toExponential(dp);

package/String.js

@@ -1,8 +1,19 @@
 import { toString as dateToString } from "./Date.js";
-import { compare as numericCompare, isNumeric, isIntegral, multiply, toExponential, toFixed, toHex, toPrecision } from "./Numeric.js";
+import { compare as numericCompare, divide, isNumeric, isIntegral, multiply, toExponential, toFixed, toHex, toPrecision } from "./Numeric.js";
 import { escape } from "./RegExp.js";
 import { toString } from "./Types.js";
 import { Exception } from "./Util.js";
+// Temporal date/time values (only present under --test:js-temporal) are not JS Dates. To avoid
+// importing the side-effecting Temporal runtime modules into this core file — which would pull
+// them into every bundle — they advertise a .NET-style formatter through this well-known symbol,
+// attached to their prototype when (and only when) those modules are loaded.
+const dateTimeFormattableSymbol = Symbol.for("Fable.DateTimeFormattable");
+function isNetDateFormattable(rep) {
+    return rep != null && typeof rep[dateTimeFormattableSymbol] === "function";
+}
+function formatDateLike(rep, format) {
+    return rep instanceof Date ? dateToString(rep, format) : rep[dateTimeFormattableSymbol](format);
+}
 const fsFormatRegExp = /(^|[^%])%([0+\- ]*)(\*|\d+)?(?:\.(\d+))?(\w)/g;
 const interpolateRegExp = /(?:(^|[^%])%([0+\- ]*)(\d+)?(?:\.(\d+))?(\w))?%P\(\)/g;
 const formatRegExp = /\{(\d+)(,-?\d+)?(?:\:([a-zA-Z])(\d{0,2})|\:(.+?))?\}/g;
@@ -236,8 +247,8 @@ function formatReplacement(rep, flags, padLength, precision, format) {
                 break;
         }
     }
-    else if (rep instanceof Date) {
-        rep = dateToString(rep);
+    else if (rep instanceof Date || isNetDateFormattable(rep)) {
+        rep = formatDateLike(rep, undefined);
     }
     else if (format === "A" && typeof rep === "string") {
         rep = "\"" + rep + "\"";
@@ -396,9 +407,14 @@ export function format(str, ...args) {
                     }
                     break;
                 case "e":
-                case "E":
-                    rep = precision != null ? toExponential(rep, precision) : toExponential(rep);
+                case "E": {
+                    precision = precision != null ? precision : 6;
+                    rep = String(toExponential(rep, precision));
+                    // .NET always signs the exponent and pads it to at least three digits
+                    const eIdx = rep.indexOf("e");
+                    rep = rep.slice(0, eIdx) + format + rep[eIdx + 1] + padLeft(rep.slice(eIdx + 2), 3, "0");
                     break;
+                }
                 case "f":
                 case "F":
                     precision = precision != null ? precision : 2;
@@ -422,7 +438,7 @@ export function format(str, ...args) {
                         const eChar = format === "G" ? "E" : "e";
                         rep = mantissa + eChar + expSign + paddedExpDigits;
                     }
-                    else {
+                    else if (rep.indexOf(".") >= 0) {
                         rep = trimEnd(trimEnd(rep, "0"), ".");
                     }
                     break;
@@ -473,7 +489,21 @@ export function format(str, ...args) {
                     }
                     if (pattern) {
                         let sign = "";
-                        rep = pattern.replace(/([0#,]+)(\.[0#]+)?/, (_, intPart, decimalPart) => {
+                        const patternStr = pattern;
+                        // Each `%` scales the value by 100 and is kept as a literal in the output
+                        const percents = (patternStr.match(/%/g) ?? []).length;
+                        if (percents > 0) {
+                            rep = multiply(rep, Math.pow(100, percents));
+                        }
+                        // .NET ignores commas placed after the decimal placeholders, hence the trailing group
+                        rep = patternStr.replace(/([0#,]+)(\.[0#]+)?(,*)/, (_, intPart, decimalPart) => {
+                            // Commas between the last integer placeholder and the decimal point scale the
+                            // value down by 1000 each; commas anywhere else only turn on digit grouping
+                            const scaleCommas = /,*$/.exec(intPart)[0].length;
+                            if (scaleCommas > 0) {
+                                intPart = intPart.substring(0, intPart.length - scaleCommas);
+                                rep = divide(rep, Math.pow(1000, scaleCommas));
+                            }
                             if (isLessThan(rep, 0)) {
                                 rep = multiply(rep, -1);
                                 sign = "-";
@@ -507,8 +537,8 @@ export function format(str, ...args) {
                     }
             }
         }
-        else if (rep instanceof Date) {
-            rep = dateToString(rep, pattern || format);
+        else if (rep instanceof Date || isNetDateFormattable(rep)) {
+            rep = formatDateLike(rep, pattern || format);
         }
         else {
             rep = toString(rep);