atomic-fns 1.1.6 → 1.2.0

package/dist/globals/index.js

@@ -18,13 +18,16 @@ export class CustomError extends Error {
     /**
      * Returns a new CustomError with the specified message.
      * @param {string} message
+     * @param {ErrorOptions} [options] Standard error options such as `cause`.
      * @constructor
      */
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
         this.name = this.constructor.name;
-        if (typeof Error.captureStackTrace === 'function') {
-            Error.captureStackTrace(this, this.constructor);
+        // V8 and Bun have it, and only Node's types declare it, which JSR's type check does not load
+        const errorType = Error;
+        if (typeof errorType.captureStackTrace === 'function') {
+            errorType.captureStackTrace(this, this.constructor);
         }
         else {
             this.stack = new Error(message).stack;
@@ -90,7 +93,7 @@ export function type(value) {
                 return 'error';
             if (value[Symbol.toStringTag])
                 return value[Symbol.toStringTag];
-            const className = str(value);
+            const className = Object.prototype.toString.call(value);
             if (className === '[object Window]')
                 return 'object';
             if (className.endsWith('Array]') || Array.isArray(value)) {
@@ -150,10 +153,6 @@ export function isObject(x) {
 export function isString(x) {
     return type(x) === 'string';
 }
-/** Check if value is an Array type. */
-export function isArray(x) {
-    return Array.isArray(x);
-}
 /**
  * Check if value is Array-like type.
  * A value is considered array-like if it's not a function and has a `.length` number property.
@@ -166,10 +165,6 @@ export function isArrayLike(x) {
 export function isNumber(x) {
     return type(x) === 'number';
 }
-/** Check if value is an integer number type. */
-export function isInteger(x) {
-    return type(x) === 'number' && Math.trunc(x) === x;
-}
 /** Check if value is a bigint type. */
 export function isBigint(x) {
     return type(x) === 'bigint';
@@ -180,15 +175,15 @@ export function isPromise(x) {
 }
 /** Check if value is a function type. */
 export function isFunction(x) {
-    return x?.constructor === Function;
+    return typeof x === 'function';
 }
 /** Check if value is an async function type. */
 export function isAsyncFunction(x) {
-    return x?.constructor.name === 'AsyncFunction';
+    return x?.constructor?.name === 'AsyncFunction';
 }
 /** Check if value is a generator function type. */
 export function isGenerator(x) {
-    return x?.constructor.constructor?.name === 'GeneratorFunction';
+    return x?.constructor?.constructor?.name === 'GeneratorFunction';
 }
 /** Check if value is `null` or `undefined`. */
 export function isNull(x) {
@@ -282,7 +277,7 @@ uuid()
  */
 export function uuid() {
     const u = Date.now().toString(16) + Math.random().toString(16) + '0'.repeat(16);
-    return [u.substr(0, 8), u.substr(8, 4), '4000-8' + u.substr(13, 3), u.substr(16, 12)].join('-');
+    return [u.slice(0, 8), u.slice(8, 12), `4000-8${u.slice(13, 16)}`, u.slice(16, 28)].join('-');
 }
 /**
  * Checks if `obj.key` is a function, and calls it with any given `args`.
@@ -292,7 +287,7 @@ export function uuid() {
  * @return `obj.key(...args)` or `undefined`.
  */
 export function call(obj, key, ...args) {
-    if (isFunction(get(key, obj))) {
+    if (isFunction(get([key], obj))) {
         return obj[key](...args);
     }
 }
@@ -302,25 +297,7 @@ export function chr(x) {
 }
 /** Convert character to Unicode code point */
 export function ord(x) {
-    return x.charCodeAt(0);
-}
-/**
- * Returns an array of the own enumerable property names of `object`.
- * @param object The given object.
- * @returns The array of object keys.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys Object.keys()}
- */
-export function keys(object) {
-    return Object.keys(object);
-}
-/**
- * Returns an array of the own enumerable property values of `object`.
- * @param object The given object.
- * @returns The array of object keys.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values Object.values()}
- */
-export function values(object) {
-    return Object.values(object);
+    return x.codePointAt(0) ?? Number.NaN;
 }
 /**
  * Check if a given property is present in a given object.
@@ -329,7 +306,7 @@ export function values(object) {
  * @returns `true` if the object has the property name.
  */
 export function has(obj, attr) {
-    return obj && attr in obj;
+    return obj != null && attr in Object(obj);
 }
 export function get(key, obj, value) {
     if (obj == null)
@@ -372,19 +349,26 @@ export function del(attr, x) {
 export function set(attr, obj, value, writable = false, enumerable = false) {
     return Object.defineProperty(obj, attr, {
         value,
+        configurable: true,
         enumerable,
         writable
     });
 }
 export const HASH_KEY = Symbol.for('HASH_KEY');
+const sealedHashes = new WeakMap();
 export function hash(obj) {
     if (typeof obj === 'string') {
         return hashCode(obj);
     }
-    if (typeof obj === 'object') {
-        if (get(HASH_KEY, obj) == null) {
+    if (typeof obj === 'object' && obj !== null) {
+        if (get(HASH_KEY, obj) != null) {
             return obj[HASH_KEY];
         }
+        if (!Object.isExtensible(obj)) {
+            if (!sealedHashes.has(obj))
+                sealedHashes.set(obj, uniqueId());
+            return sealedHashes.get(obj);
+        }
         obj[HASH_KEY] = uniqueId();
         return obj[HASH_KEY];
     }

package/dist/i18n/currency.d.ts

@@ -6,19 +6,22 @@ export declare class Currency extends Decimal {
     private readonly locale;
     private readonly currency;
     private readonly numberFormat;
+    private readonly overrides;
     private readonly options;
     constructor(amount: any, currency: string, locale?: string, opts?: Intl.NumberFormatOptions);
-    clone(n: any): Currency;
+    clone(n: Currency): Currency;
     negated(): Currency;
-    add(x: any): Currency;
-    sub(x: any): Currency;
-    div(x: any): Currency;
-    mul(x: any): Currency;
-    toDecimal(): any;
+    add(x: Currency | string): Currency;
+    sub(x: Currency | string): Currency;
+    div(x: Currency | Decimal | string | number): Currency;
+    mul(x: Currency | Decimal): Currency;
+    toDecimal(): Decimal;
+    /** `Intl` reads a decimal string exactly, while a `Number` past 2^53 has lost digits. */
+    private formattable;
     toString(): string;
     format(opts?: Intl.NumberFormatOptions, locale?: string): string;
     displayName(): string;
     accounting(): string;
     precision(digits?: number): string;
-    eq(x: any): any;
+    eq(x: any): boolean;
 }

package/dist/i18n/currency.js

@@ -1,6 +1,8 @@
 import { defaults } from '../collections/index.js';
 import { isObject } from '../globals/index.js';
 import { Decimal } from '../decimal/index.js';
+/** `Intl` options that set the digits shown. Some reject each other, so they replace as a group. */
+const DIGIT_OPTION = /^(minimum|maximum)(Fraction|Significant)Digits$|^rounding(Increment|Priority)$/;
 /**
  * Currency represents a local currency amount that can be formatted using the `Intl` apis.
  */
@@ -8,6 +10,7 @@ export class Currency extends Decimal {
     locale;
     currency;
     numberFormat;
+    overrides;
     options = {
         style: 'currency',
         currencyDisplay: 'symbol',
@@ -19,16 +22,17 @@ export class Currency extends Decimal {
             opts = locale;
             locale = undefined;
         }
-        const systemLocale = new Intl.NumberFormat(locale, defaults(opts, { currency }, this.options));
+        const systemLocale = new Intl.NumberFormat(locale, defaults({}, opts, { currency }, this.options));
         const resolved = systemLocale.resolvedOptions();
         this.numberFormat = systemLocale;
         this.options.currency = currency;
+        this.overrides = defaults({}, opts);
         this.currency = resolved.currency;
         this.locale = resolved.locale;
     }
     // @ts-expect-error overrides
     clone(n) {
-        return new Currency(n, this.currency, this.locale, this.options);
+        return new Currency(n === undefined ? this : n, this.currency, this.locale, this.overrides);
     }
     // @ts-expect-error overrides
     negated() {
@@ -58,14 +62,25 @@ export class Currency extends Decimal {
     toDecimal() {
         return super.clone.call(this);
     }
-    toString() {
+    /** `Intl` reads a decimal string exactly, while a `Number` past 2^53 has lost digits. */
+    formattable() {
         const number = this.toNumber();
-        return this.numberFormat.format(number);
+        if (Math.abs(number) <= Number.MAX_SAFE_INTEGER)
+            return number;
+        return Decimal.prototype.toString.call(this);
+    }
+    toString() {
+        return this.numberFormat.format(this.formattable());
     }
     format(opts = {}, locale) {
-        const number = this.toNumber();
-        opts = defaults(opts, this.options);
-        return new Intl.NumberFormat(locale ?? this.locale, opts).format(number);
+        const overrides = { ...this.overrides };
+        if (Object.keys(opts).some((key) => DIGIT_OPTION.test(key) && opts[key] !== undefined)) {
+            for (const key in overrides)
+                if (DIGIT_OPTION.test(key))
+                    delete overrides[key];
+        }
+        opts = defaults({}, opts, overrides, this.options);
+        return new Intl.NumberFormat(locale ?? this.locale, opts).format(this.formattable());
     }
     displayName() {
         return this.format({ currencyDisplay: 'name' });

package/dist/i18n/date/index.d.ts

@@ -1,10 +1,9 @@
-import { Duration, DurationUnit, TDuration } from '../duration.js';
+import { Duration, type DurationUnit, type TDuration } from '../duration.js';
 import { asDate, formatDate, strftime } from '../format.js';
-import { DateObject, daysInMonth, daysInYear, isLeapYear, maxDate, minDate, weeksInYear } from './utils.js';
+import { type DateObject, daysInMonth, daysInYear, isLeapYear, maxDate, minDate, weeksInYear } from './utils.js';
 export { asDate, daysInMonth, daysInYear, formatDate, isLeapYear, maxDate, minDate, strftime, weeksInYear };
-export { DateObject };
-export declare type DateInput = number | string | Date;
-export declare type DateLike = DateInput | IntlDate | DateObject;
+export type { DateObject };
+export type DateLike = number | string | Date | IntlDate | DateObject;
 /**
  * Creates a date tied to a given locale (default system locale) which can be formatted in that locale's language using the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl Intl Apis} directly or using a formatting string.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl Intl Apis}
@@ -15,7 +14,7 @@ export declare class IntlDate {
     intlRelativeFormat: Intl.RelativeTimeFormat;
     /** Parses the provided value as UTC date or returns the current UTC date. */
     static UTC(value?: DateLike, locale?: string): IntlDate;
-    /** Returns the current local date and time.*/
+    /** Returns the current local date and time. */
     static now(): IntlDate;
     /** Creates a new date from a Unix timestamp (seconds since the unix epoch) */
     static unix(seconds: number): IntlDate;
@@ -53,14 +52,14 @@ export declare class IntlDate {
     dayOfYear(): number;
     /** Returns `true` if this date's year is a leap year. */
     isLeapYear(): boolean;
-    /** Gets the number of weeks according to locale in the current year. */
+    /** Gets the number of Monday-first weeks in the current year, where week 1 is the first full week. */
     weeksInYear(): number;
     /** Gets the number of weeks in the current year, according to ISO weeks. */
     isoWeeksInYear(): number;
     /** Returns the current week of the year. */
-    week(): any;
+    week(): number;
     /** Returns the ISO week of the year. */
-    isoWeek(): any;
+    isoWeek(): number;
     /**
      * Returns a localized string representation of this date.
      * @param {Intl.DateTimeFormatOptions} opts The options to use for the format
@@ -129,13 +128,13 @@ export declare class IntlDate {
     /** Returns the time part formatted as ISO8601.
      * @example
   ```js
-  new IntlDate().toISOTime() // 'T22:44:30.652Z'
+  new IntlDate().toISOTime() // '22:44:30.652Z'
   ```
      */
     toISOTime(): string;
     /**
      * Returns an object containing year, month, day-of-month, hours, minutes, seconds, milliseconds.
-     * @returns {Object} An object like `{year, month, date, hours, minutes, seconds, ms}`
+     * @returns {Object} An object like `{year, month, day, hour, minute, second, millisecond}`
      */
     toObject(): DateObject;
     /** Returns the number of milliseconds since the Unix Epoch (January 1, 1970 UTC)  */
@@ -186,19 +185,26 @@ export declare class IntlDate {
     diff(other: DateLike, unit?: DurationUnit, exact?: boolean): number;
     add(duration: TDuration, exact?: boolean): IntlDate;
     subtract(duration: TDuration, exact?: boolean): IntlDate;
-    startOf(unit: DurationUnit): IntlDate;
-    endOf(unit: DurationUnit): IntlDate;
+    startOf(unit: DurationUnit): any;
+    endOf(unit: DurationUnit): any;
     clone(date?: DateLike): IntlDate;
     static max(...args: any[]): any;
     static min(...args: any[]): any;
     inspect(): string;
 }
-export declare function addDuration(date: DateInput, duration: number | Duration | TDuration, exact?: boolean): Date;
+/**
+ * Add the specified years, months, weeks, days, hours, minutes and seconds to the given date
+ * @param date
+ * @param duration
+ * @param exact Kept for callers that pass it, it no longer changes the result.
+ * @returns
+ */
+export declare function addDuration(date: number | string | Date, duration: number | Duration | TDuration, exact?: boolean): Date;
 /**
  * Subtract the specified years, months, weeks, days, hours, minutes and seconds from the given date.
  * @param date
  * @param duration
- * @param exact
+ * @param exact Kept for callers that pass it, it no longer changes the result.
  * @returns
  */
-export declare function subDuration(date: DateInput, duration: number | Duration | TDuration, exact?: boolean): Date;
+export declare function subDuration(date: number | string | Date, duration: number | Duration | TDuration, exact?: boolean): Date;

package/dist/i18n/date/index.js

@@ -1,6 +1,6 @@
 import { isObject, ValueError } from '../../globals/index.js';
 import { Duration, UNITS_PLURAL } from '../duration.js';
-import { asDate, formatDate, strftime } from '../format.js';
+import { asDate, formatDate, fromFields, strftime } from '../format.js';
 import { asNumber, dayOfYear, daysInMonth, daysInYear, isLeapYear, maxDate, minDate, weekOfYear, weeksInYear } from './utils.js';
 // Export date functions
 export { asDate, daysInMonth, daysInYear, formatDate, isLeapYear, maxDate, minDate, strftime, weeksInYear };
@@ -17,7 +17,7 @@ export class IntlDate {
     static UTC(value, locale) {
         return new IntlDate(value, { utc: true, locale });
     }
-    /** Returns the current local date and time.*/
+    /** Returns the current local date and time. */
     static now() {
         return new IntlDate();
     }
@@ -45,16 +45,8 @@ export class IntlDate {
         else if (isObject(obj)) {
             let { year, month, day, hour, minute, second, millisecond } = obj;
             // NOTE month is from 1-12, not from 0-11
-            if (typeof month === 'number') {
-                month -= 1;
-            }
-            if (utc) {
-                // from UTC to current
-                this._date = new Date(Date.UTC(year, month, day || 1, hour || 0, minute || 0, second || 0, millisecond || 0));
-            }
-            else {
-                this._date = new Date(year, month, day || 1, hour || 0, minute || 0, second || 0, millisecond || 0);
-            }
+            month = (month ?? 1) - 1;
+            this._date = fromFields(utc, Number(year), month, day || 1, hour || 0, minute || 0, second || 0, millisecond || 0);
         }
         else {
             this._date = asDate(obj, utc);
@@ -113,7 +105,7 @@ export class IntlDate {
     isLeapYear() {
         return isLeapYear(this.year);
     }
-    /** Gets the number of weeks according to locale in the current year. */
+    /** Gets the number of Monday-first weeks in the current year, where week 1 is the first full week. */
     weeksInYear() {
         return weeksInYear(this.year);
     }
@@ -208,20 +200,20 @@ export class IntlDate {
   ```
      */
     toISODate() {
-        return this._date.toISOString().slice(0, 10);
+        return this._date.toISOString().split('T')[0];
     }
     /** Returns the time part formatted as ISO8601.
      * @example
   ```js
-  new IntlDate().toISOTime() // 'T22:44:30.652Z'
+  new IntlDate().toISOTime() // '22:44:30.652Z'
   ```
      */
     toISOTime() {
-        return this._date.toISOString().slice(11);
+        return this._date.toISOString().split('T')[1];
     }
     /**
      * Returns an object containing year, month, day-of-month, hours, minutes, seconds, milliseconds.
-     * @returns {Object} An object like `{year, month, date, hours, minutes, seconds, ms}`
+     * @returns {Object} An object like `{year, month, day, hour, minute, second, millisecond}`
      */
     toObject() {
         return {
@@ -248,7 +240,10 @@ export class IntlDate {
     }
     /** Returns the timezone GMT offset as a string  */
     zone() {
-        return this.format('ZZ');
+        if (!this.isValid())
+            return INVALID_DATE_STRING;
+        const zoneFormat = new Intl.DateTimeFormat(this.locale, { timeZoneName: 'longOffset' });
+        return zoneFormat.formatToParts(this._date).find((part) => part.type === 'timeZoneName').value;
     }
     /** Returns the difference in `minutes` between this date and UTC  */
     utcOffset() {
@@ -308,7 +303,7 @@ export class IntlDate {
     compare(other) {
         if (!this.isValid())
             return 1;
-        let dt = new IntlDate(other);
+        const dt = new IntlDate(other);
         if (!dt.isValid())
             return -1;
         return this.getTime() - dt.getTime();
@@ -317,13 +312,18 @@ export class IntlDate {
         if (!this.isValid())
             return this;
         const normalized = normalizeObject(values, normalizeUnit);
-        let mixed = { ...this.toObject(), ...normalized };
+        const mixed = { ...this.toObject(), ...normalized };
         // if we didn't set the day but we ended up on an overflow date,
         // use the last day of the right month
         if (normalized.day === undefined) {
-            mixed.day = Math.min(daysInMonth(this._date), mixed.day);
+            const target = new Date(this._date);
+            target.setFullYear(mixed.year, mixed.month - 1, 1);
+            mixed.day = Math.min(daysInMonth(target), mixed.day);
         }
-        return this.clone(mixed);
+        const result = this.clone(mixed);
+        return normalized.weekday === undefined
+            ? result
+            : result.add({ days: normalized.weekday - result.dayOfWeek });
     }
     get relativeFormat() {
         if (this.intlRelativeFormat)
@@ -332,27 +332,42 @@ export class IntlDate {
         return new Intl.RelativeTimeFormat(this.locale);
     }
     relativeTime(n, unit = 'seconds') {
-        return this.relativeFormat.format(n, unit);
+        return Number.isNaN(n) ? INVALID_DATE_STRING : this.relativeFormat.format(n, unit);
     }
     fromNow(unit = 'seconds') {
-        let diff = this.diff(new Date(), unit);
+        const diff = this.diff(new Date(), unit);
         return this.relativeTime(diff, unit);
     }
     from(other, unit = 'seconds') {
-        let diff = this.diff(other, unit);
+        const diff = this.diff(other, unit);
         return this.relativeTime(diff, unit);
     }
     toNow(unit = 'seconds') {
-        let diff = this.diff(new Date(), unit);
+        const diff = this.diff(new Date(), unit);
         return this.relativeTime(-diff, unit);
     }
     to(other, unit = 'seconds') {
-        let diff = this.diff(other, unit);
+        const diff = this.diff(other, unit);
         return this.relativeTime(-diff, unit);
     }
     diff(other, unit = 'milliseconds', exact = false) {
-        let dt = new IntlDate(other);
-        let dur = new Duration(this.getTime() - dt.getTime(), exact);
+        const dt = new IntlDate(other);
+        const normalizedUnit = UNITS_PLURAL[unit.toLowerCase()];
+        const monthsInUnit = MONTHS_IN_UNIT[normalizedUnit];
+        if (monthsInUnit && !exact) {
+            // whole months are the ones `add` can take from `other` without passing this date
+            let months = (this.year - dt.year) * 12 + this.month - dt.month;
+            const sign = Math.sign(this.getTime() - dt.getTime());
+            if (sign * (dt.add({ months }).getTime() - this.getTime()) > 0)
+                months -= sign;
+            return Math.trunc(months / monthsInUnit);
+        }
+        let elapsed = this.getTime() - dt.getTime();
+        if (normalizedUnit === 'days' || normalizedUnit === 'weeks') {
+            // a calendar day can last 23 or 25 hours, so measure it on the wall clock
+            elapsed += (dt._date.getTimezoneOffset() - this._date.getTimezoneOffset()) * 6e4;
+        }
+        const dur = new Duration(elapsed, exact);
         let total = dur.total(unit);
         if (!exact)
             total = Math.trunc(total);
@@ -367,7 +382,8 @@ export class IntlDate {
     startOf(unit) {
         if (!this.isValid())
             return this;
-        const obj = {}, normalizedUnit = UNITS_PLURAL[unit.toLowerCase()];
+        const obj = {};
+        const normalizedUnit = UNITS_PLURAL[unit.toLowerCase()];
         switch (normalizedUnit) {
             case 'years':
                 obj.month = 1;
@@ -391,16 +407,22 @@ export class IntlDate {
                 break;
             case 'milliseconds':
                 break;
-            // no default, invalid units throw in normalizeUnit()
+            // no default, an unknown unit changes nothing
         }
         if (normalizedUnit === 'weeks') {
-            obj.weekday = 1;
+            return this.subtract({ days: this.dayOfWeek - 1 }).startOf('days');
         }
         if (normalizedUnit === 'quarters') {
             const q = Math.ceil(this.month / 3);
             obj.month = (q - 1) * 3 + 1;
         }
-        return this.set(obj);
+        const start = this.set(obj);
+        if (obj.hour !== undefined)
+            return start;
+        // Date reads a repeated wall clock as its first pass, this date may be on the second
+        const offset = this._date.getTimezoneOffset();
+        const kept = new Date(start.getTime() + (offset - start._date.getTimezoneOffset()) * 6e4);
+        return kept.getTimezoneOffset() === offset ? this.clone(kept) : start;
     }
     endOf(unit) {
         return this.isValid()
@@ -419,57 +441,56 @@ export class IntlDate {
         return minDate.apply(undefined, args);
     }
     inspect() {
-        return `new IntlDate("${this.toISOString()}")`;
+        return this.isValid() ? `new IntlDate("${this.toISOString()}")` : 'new IntlDate(NaN)';
     }
 }
-// Check if the new offset is different because we crossed to DST
-function fixOffset(startDate, endDate) {
-    let startOffset = startDate.getTimezoneOffset();
-    let endOffset = endDate.getTimezoneOffset();
-    if (startOffset === endOffset)
-        return new Date(endDate);
-    let postoffset = (startOffset - endOffset) * 60 * 1000;
-    return new Date(+endDate + postoffset);
-}
+/**
+ * Add the specified years, months, weeks, days, hours, minutes and seconds to the given date
+ * @param date
+ * @param duration
+ * @param exact Kept for callers that pass it, it no longer changes the result.
+ * @returns
+ */
 export function addDuration(date, duration, exact = false) {
-    // Get the current offset of this date timezone
-    let newDate = new Date(date);
-    // Get the number of ticks forward
-    let { values } = new Duration(duration, exact).normalize();
-    // Apply any time changes that may have happened
-    for (const unit in values) {
-        setDateUnit(newDate, unit, Math.floor(values[unit]));
-    }
-    return fixOffset(new Date(date), newDate);
+    const newDate = asDate(date);
+    const { values } = new Duration(duration, exact);
+    const { years = 0, quarters = 0, months = 0, weeks = 0, days = 0 } = values;
+    // largest unit first and all the months in one step, so a clamped day cannot carry over
+    setDateUnit(newDate, 'months', Math.trunc(years * 12 + quarters * 3 + Number(months)));
+    setDateUnit(newDate, 'days', Math.trunc(weeks * 7 + Number(days)));
+    for (const unit of ['hours', 'minutes', 'seconds', 'milliseconds']) {
+        setDateUnit(newDate, unit, Number(values[unit] ?? 0));
+    }
+    return newDate;
+}
+function addMonths(date, months) {
+    const target = new Date(date);
+    target.setFullYear(date.getFullYear(), date.getMonth() + months, 1);
+    const day = Math.min(date.getDate(), daysInMonth(target));
+    date.setFullYear(target.getFullYear(), target.getMonth(), day);
 }
 function setDateUnit(date, unit, value) {
+    // writing a date field again would move a repeated hour to its first pass
+    if (value === 0)
+        return date;
     switch (unit) {
-        case 'years':
-            date.setFullYear(date.getFullYear() + value);
-            break;
-        case 'quarters':
-            date.setMonth(date.getMonth() + value * 3);
-            break;
         case 'months':
-            date.setMonth(date.getMonth() + value);
-            break;
-        case 'weeks':
-            date.setDate(date.getDate() + value * 7);
+            addMonths(date, value);
             break;
         case 'days':
             date.setDate(date.getDate() + value);
             break;
         case 'hours':
-            date.setHours(date.getHours() + value);
+            date.setTime(date.getTime() + value * 36e5);
             break;
         case 'minutes':
-            date.setMinutes(date.getMinutes() + value);
+            date.setTime(date.getTime() + value * 6e4);
             break;
         case 'seconds':
-            date.setSeconds(date.getSeconds() + value);
+            date.setTime(date.getTime() + value * 1e3);
             break;
         case 'milliseconds':
-            date.setMilliseconds(date.getMilliseconds() + value);
+            date.setTime(date.getTime() + value);
             break;
         default:
             break;
@@ -480,12 +501,13 @@ function setDateUnit(date, unit, value) {
  * Subtract the specified years, months, weeks, days, hours, minutes and seconds from the given date.
  * @param date
  * @param duration
- * @param exact
+ * @param exact Kept for callers that pass it, it no longer changes the result.
  * @returns
  */
 export function subDuration(date, duration, exact = false) {
     return addDuration(date, new Duration(duration, exact).negated(), exact);
 }
+const MONTHS_IN_UNIT = { years: 12, quarters: 3, months: 1 };
 const UNITS_SINGULAR = {
     year: 'year',
     years: 'year',