atomic-fns 1.1.7 → 1.2.0

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,9 +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 DateLike = number | string | Date | 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}
@@ -52,7 +52,7 @@ 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;
@@ -128,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)  */
@@ -185,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;
 }
+/**
+ * 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: 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 };
@@ -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() {
@@ -321,9 +316,14 @@ export class IntlDate {
         // 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,7 +332,7 @@ 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') {
         const diff = this.diff(new Date(), unit);
@@ -352,7 +352,22 @@ export class IntlDate {
     }
     diff(other, unit = 'milliseconds', exact = false) {
         const dt = new IntlDate(other);
-        const dur = new Duration(this.getTime() - dt.getTime(), exact);
+        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);
@@ -392,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()
@@ -420,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) {
-    const startOffset = startDate.getTimezoneOffset();
-    const endOffset = endDate.getTimezoneOffset();
-    if (startOffset === endOffset)
-        return new Date(endDate);
-    const 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
-    const newDate = new Date(date);
-    // Get the number of ticks forward
-    const { 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;
@@ -481,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',

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

@@ -51,11 +51,10 @@ export declare function parseISODuration(s: any): any;
 export declare function weeksInYear(year: number, firstDayOfWeek?: number, firstDayOfYear?: number): number;
 /**
  * Returns the week of the year for the specified date
- * @param year
- * @param dayOfYear
- * @param firstDayOfWeek
- * @param firstDayOfYear
- * @returns
+ * @param date The date value
+ * @param firstDayOfWeek The weekday a week starts on, where Sunday is 0
+ * @param firstDayOfYear Picks week 1: the week holding January `7 + firstDayOfWeek - firstDayOfYear`, so `1, 4` gives ISO weeks
+ * @returns The week and the year that week belongs to
  */
 export declare function weekOfYear(date: string | number | Date, firstDayOfWeek?: number, firstDayOfYear?: number): {
     week: any;

package/dist/i18n/date/utils.js

@@ -1,3 +1,4 @@
+import { asDate } from '../format.js';
 /**
  * Returns x % n but takes the sign of n instead of x
  * @param x
@@ -7,28 +8,13 @@
 function floorMod(x, n) {
     return x - n * Math.floor(x / n);
 }
-function padStart(input, n = 2) {
-    const isNeg = input < 0;
-    let padded;
-    if (isNeg) {
-        padded = '-' + ('' + -input).padStart(n, '0');
-    }
-    else {
-        padded = ('' + input).padStart(n, '0');
-    }
-    return padded;
-}
-function parseInteger(str) {
-    if (str != null && str !== '')
-        return parseInt(str, 10);
-}
 function parseFloating(str) {
     if (str != null && str !== '')
         return parseFloat(str);
 }
 function parseMilliseconds(str) {
     if (str != null && str !== '') {
-        const f = parseFloat('0.' + str) * 1000;
+        const f = parseFloat(`0.${str}`) * 1000;
         return Math.floor(f);
     }
 }
@@ -39,7 +25,7 @@ export function minDate(...dates) {
         ans = ans[0];
     }
     for (let i = 1; i < dates.length; i++) {
-        if (dates[i].valueOf() < ans.valueOf()) {
+        if (dates[i].valueOf() < ans.valueOf() || Number.isNaN(ans.valueOf())) {
             ans = dates[i];
         }
     }
@@ -52,7 +38,7 @@ export function maxDate(...dates) {
         ans = ans[0];
     }
     for (let i = 1; i < dates.length; i++) {
-        if (dates[i].valueOf() > ans.valueOf()) {
+        if (dates[i].valueOf() > ans.valueOf() || Number.isNaN(ans.valueOf())) {
             ans = dates[i];
         }
     }
@@ -80,7 +66,7 @@ export function daysInYear(year) {
  * @returns {number} Number of days in month
  */
 export function daysInMonth(date) {
-    const d = new Date(date), year = d.getFullYear(), month = d.getMonth() + 1;
+    const d = asDate(date), year = d.getFullYear(), month = d.getMonth() + 1;
     const modMonth = floorMod(month - 1, 12) + 1, modYear = year + (month - modMonth) / 12;
     if (modMonth === 2) {
         return isLeapYear(modYear) ? 29 : 28;
@@ -89,51 +75,6 @@ export function daysInMonth(date) {
         return [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][modMonth - 1];
     }
 }
-// covert a calendar object to a local timestamp (epoch, but with the offset baked in)
-function objToLocalTS(obj) {
-    let d = Date.UTC(obj.year, obj.month - 1, obj.day, obj.hour, obj.minute, obj.second, obj.millisecond);
-    // for legacy reasons, years between 0 and 99 are interpreted as 19XX; revert that
-    if (obj.year < 100 && obj.year >= 0) {
-        let dt = new Date(d);
-        dt.setUTCFullYear(dt.getUTCFullYear() - 1900);
-        d = dt.getTime();
-    }
-    return +d;
-}
-function untruncateYear(year) {
-    if (year > 99) {
-        return year;
-    }
-    else
-        return year > 60 ? 1900 + year : 2000 + year;
-}
-// PARSING
-function parseZoneInfo(ts, offsetFormat, locale, timeZone) {
-    const date = new Date(ts), intlOpts = {
-        hourCycle: 'h23',
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        timeZone,
-        timeZoneName: offsetFormat
-    };
-    const parsed = new Intl.DateTimeFormat(locale, intlOpts)
-        .formatToParts(date)
-        .find((m) => m.type === 'timeZoneName');
-    return parsed?.value;
-}
-// signedOffset('-5', '30') -> -330
-function signedOffset(offHourStr, offMinuteStr) {
-    let offHour = parseInt(offHourStr, 10);
-    // don't || this because we want to preserve -0
-    if (Number.isNaN(offHour)) {
-        offHour = 0;
-    }
-    const offMin = parseInt(offMinuteStr, 10) || 0, offMinSigned = offHour < 0 || Object.is(offHour, -0) ? -offMin : offMin;
-    return offHour * 60 + offMinSigned;
-}
 // COERCION
 export function asNumber(value) {
     const numericValue = Number(value);
@@ -141,24 +82,6 @@ export function asNumber(value) {
         throw new Error(`Invalid unit value ${value}`);
     return numericValue;
 }
-function formatOffset(offset, format) {
-    const hours = Math.trunc(Math.abs(offset / 60)), minutes = Math.trunc(Math.abs(offset % 60)), sign = offset >= 0 ? '+' : '-';
-    switch (format) {
-        case 'short':
-            return `${sign}${padStart(hours, 2)}:${padStart(minutes, 2)}`;
-        case 'narrow':
-            return `${sign}${hours}${minutes > 0 ? `:${minutes}` : ''}`;
-        case 'techie':
-            return `${sign}${padStart(hours, 2)}${padStart(minutes, 2)}`;
-        default:
-            throw new RangeError(`Value format ${format} is out of range for property format`);
-    }
-}
-function timeObject(obj) {
-    const { hour, minute, second, millisecond } = obj;
-    return { hour, minute, second, millisecond };
-}
-const ianaRegex = /[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/;
 const isoDuration = /^-?P(?:(?:(-?\d{1,20}(?:\.\d{1,20})?)Y)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20}(?:\.\d{1,20})?)W)?(?:(-?\d{1,20}(?:\.\d{1,20})?)D)?(?:T(?:(-?\d{1,20}(?:\.\d{1,20})?)H)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,20}))?S)?)?)$/;
 function extractISODuration(match) {
     const [s, yearStr, monthStr, weekStr, dayStr, hourStr, minuteStr, secondStr, millisecondsStr] = match;
@@ -197,16 +120,15 @@ function createUTCDate(...args) {
     let date, y = args[0];
     // the Date.UTC function remaps years 0-99 to 1900-1999
     if (y < 100 && y >= 0) {
-        args = Array.from(arguments);
         // preserve leap years using a full 400 year cycle, then reset
         args[0] = y + 400;
         date = new Date(Date.UTC.apply(null, args));
-        if (isFinite(date.getUTCFullYear())) {
+        if (Number.isFinite(date.getUTCFullYear())) {
             date.setUTCFullYear(y);
         }
     }
     else {
-        date = new Date(Date.UTC.apply(null, arguments));
+        date = new Date(Date.UTC.apply(null, args));
     }
     return date;
 }
@@ -217,26 +139,6 @@ function firstWeekOffset(year, dow, doy) {
     fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
     return -fwdlw + fwd - 1;
 }
-// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
-function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
-    var localWeekday = (7 + weekday - dow) % 7, weekOffset = firstWeekOffset(year, dow, doy), dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, resYear, resDayOfYear;
-    if (dayOfYear <= 0) {
-        resYear = year - 1;
-        resDayOfYear = daysInYear(resYear) + dayOfYear;
-    }
-    else if (dayOfYear > daysInYear(year)) {
-        resYear = year + 1;
-        resDayOfYear = dayOfYear - daysInYear(year);
-    }
-    else {
-        resYear = year;
-        resDayOfYear = dayOfYear;
-    }
-    return {
-        year: resYear,
-        dayOfYear: resDayOfYear
-    };
-}
 /**
  * Returns the number of weeks in the specified year.
  * @param year
@@ -249,14 +151,13 @@ export function weeksInYear(year, firstDayOfWeek = 1, firstDayOfYear = 1) {
 }
 /**
  * Returns the week of the year for the specified date
- * @param year
- * @param dayOfYear
- * @param firstDayOfWeek
- * @param firstDayOfYear
- * @returns
+ * @param date The date value
+ * @param firstDayOfWeek The weekday a week starts on, where Sunday is 0
+ * @param firstDayOfYear Picks week 1: the week holding January `7 + firstDayOfWeek - firstDayOfYear`, so `1, 4` gives ISO weeks
+ * @returns The week and the year that week belongs to
  */
 export function weekOfYear(date, firstDayOfWeek = 1, firstDayOfYear = 1) {
-    const year = new Date(date).getFullYear();
+    const year = asDate(date).getFullYear();
     const doy = dayOfYear(date);
     let weekOffset = firstWeekOffset(year, firstDayOfWeek, firstDayOfYear), week = Math.floor((doy - weekOffset - 1) / 7) + 1, resWeek, resYear;
     if (week < 1) {
@@ -280,11 +181,12 @@ export function isoWeeksInYear(year) {
     return weeksInYear(year, 1, 4);
 }
 export function dayOfYear(input) {
-    input = new Date(input);
+    input = asDate(input);
     input.setHours(0);
     input.setMinutes(0);
     input.setSeconds(0);
     input.setMilliseconds(0);
-    let start = new Date(input.getFullYear(), 0, 1, 0, 0, 0, 0);
+    const start = new Date(input);
+    start.setMonth(0, 1);
     return Math.round((+input - start.getTime()) / 864e5) + 1;
 }