@naturalcycles/js-lib 15.100.0 → 15.102.0

package/dist/abort.d.ts

@@ -28,14 +28,6 @@ export declare function createAbortableSignal(): AbortableSignal;
  * Otherwise returns undefined.
  */
 export declare function abortSignalTimeoutOrUndefined(ms: NumberOfMilliseconds | undefined): AbortSignal | undefined;
-/**
- * Returns an AbortSignal that aborts after the given number of milliseconds.
- * Uses native `AbortSignal.timeout()` when available, falls back to a polyfill.
- *
- * The abort reason is a DOMException with name "TimeoutError".
- */
-export declare function abortSignalTimeout(ms: NumberOfMilliseconds): AbortSignal;
-export declare function polyfilledAbortSignalTimeout(ms: NumberOfMilliseconds): AbortSignal;
 /**
  * Returns AbortSignal.any(signals) is the array (after filtering undefined inputs) is not empty,
  * otherwise undefined.

package/dist/abort.js

@@ -16,25 +16,7 @@ export function createAbortableSignal() {
  * Otherwise returns undefined.
  */
 export function abortSignalTimeoutOrUndefined(ms) {
-    return ms ? abortSignalTimeout(ms) : undefined;
-}
-/**
- * Returns an AbortSignal that aborts after the given number of milliseconds.
- * Uses native `AbortSignal.timeout()` when available, falls back to a polyfill.
- *
- * The abort reason is a DOMException with name "TimeoutError".
- */
-export function abortSignalTimeout(ms) {
-    return typeof AbortSignal.timeout === 'function'
-        ? AbortSignal.timeout(ms)
-        : polyfilledAbortSignalTimeout(ms);
-}
-export function polyfilledAbortSignalTimeout(ms) {
-    const ac = new AbortController();
-    setTimeout(() => {
-        ac.abort(new DOMException('The operation was aborted due to timeout', 'TimeoutError'));
-    }, ms);
-    return ac.signal;
+    return ms ? AbortSignal.timeout(ms) : undefined;
 }
 /**
  * Returns AbortSignal.any(signals) is the array (after filtering undefined inputs) is not empty,
@@ -57,6 +39,7 @@ export function abortSignalAny(signals) {
     if (signals.length === 1) {
         return signals[0];
     }
+    // AbortSignal.any needs Chrome 116+ / Safari 17.4+, above our browser floor (Chrome 110, iOS 16.7)
     return typeof AbortSignal.any === 'function'
         ? AbortSignal.any(signals) // lib.dom types require a mutable array, but it is only read
         : polyfilledAbortSignalAny(signals);

package/dist/array/array.util.d.ts

@@ -99,9 +99,7 @@ export declare function _find<T>(items: readonly T[], predicate: AbortablePredic
 /**
  * Similar to `Array.findLast`, but the `predicate` may return `END` to stop the iteration early.
  *
- * Use `Array.findLast` if you don't need to stop the iteration early, which is supported:
- * - in Node since 18+
- * - in iOS Safari since 15.4
+ * Use `Array.findLast` if you don't need to stop the iteration early.
  */
 export declare function _findLast<T>(items: readonly T[], predicate: AbortablePredicate<T>): T | undefined;
 export declare function _takeWhile<T>(items: readonly T[], predicate: Predicate<T>): T[];

package/dist/array/array.util.js

@@ -174,9 +174,7 @@ export function _find(items, predicate) {
 /**
  * Similar to `Array.findLast`, but the `predicate` may return `END` to stop the iteration early.
  *
- * Use `Array.findLast` if you don't need to stop the iteration early, which is supported:
- * - in Node since 18+
- * - in iOS Safari since 15.4
+ * Use `Array.findLast` if you don't need to stop the iteration early.
  */
 export function _findLast(items, predicate) {
     return _find(items.toReversed(), predicate);

package/dist/array/sort.js

@@ -42,7 +42,7 @@ class Comparators {
         return b.created - a.created;
     }
 }
-export const comparators = new Comparators();
+export const comparators = /* @__PURE__ */ new Comparators();
 /**
  * _sortBy([{age: 20}, {age: 10}], 'age')
  * // => [{age: 10}, {age: 20}]

package/dist/array/sortedSet.d.ts

@@ -1,4 +1,4 @@
-import { Set2 } from '../object/index.js';
+import { Set2 } from '../object/set2.js';
 import type { Comparator } from '../types.js';
 export interface SortedSetOptions<T> {
     /**

package/dist/array/sortedSet.js

@@ -1,4 +1,4 @@
-import { Set2 } from '../object/index.js';
+import { Set2 } from '../object/set2.js';
 /**
  * Like Set, but keeps members sorted after every insertion.
  */

package/dist/asyncManager.js

@@ -1,3 +1,4 @@
+import { nowUnixMillis } from './datetime/time.util.js';
 import { consoleLogger } from './log/commonLogger.js';
 class AsyncManagerImpl {
     logger = consoleLogger;
@@ -24,7 +25,7 @@ class AsyncManagerImpl {
         if (!size)
             return;
         const { logger } = this;
-        const started = Date.now();
+        const started = nowUnixMillis();
         if (timeout) {
             const result = await Promise.race([
                 Promise.allSettled(this.pendingOps),
@@ -38,7 +39,7 @@ class AsyncManagerImpl {
         else {
             await Promise.allSettled(this.pendingOps);
         }
-        logger.log(`AsyncManager.allDone for ${size} op(s) in ${Date.now() - started} ms`);
+        logger.log(`AsyncManager.allDone for ${size} op(s) in ${nowUnixMillis() - started} ms`);
     }
     reset() {
         this.pendingOps.clear();
@@ -81,6 +82,6 @@ class AsyncManagerImpl {
  *
  * @experimental
  */
-export const AsyncManager = new AsyncManagerImpl();
+export const AsyncManager = /* @__PURE__ */ new AsyncManagerImpl();
 // Shorthand alias
-export const runInBackground = AsyncManager.runInBackground.bind(AsyncManager);
+export const runInBackground = /* @__PURE__ */ AsyncManager.runInBackground.bind(AsyncManager);

package/dist/browser/analytics.util.js

@@ -1,3 +1,4 @@
+import { newDate, nowUnixMillis } from '../datetime/time.util.js';
 import { isServerSide } from '../env.js';
 import { loadScript } from './script.util.js';
 /**
@@ -10,7 +11,7 @@ export async function loadGTag(gtagId, enabled = true) {
     globalThis.gtag ||= function gtag() {
         globalThis.dataLayer.push(arguments);
     };
-    globalThis.gtag('js', new Date());
+    globalThis.gtag('js', newDate());
     globalThis.gtag('config', gtagId);
     if (!enabled)
         return;
@@ -21,7 +22,7 @@ export async function loadGTM(gtmId, enabled = true) {
         return;
     globalThis.dataLayer ||= [];
     globalThis.dataLayer.push({
-        'gtm.start': Date.now(),
+        'gtm.start': nowUnixMillis(),
         event: 'gtm.js',
     });
     if (!enabled)

package/dist/browser/topbar.js

@@ -60,7 +60,7 @@ const createCanvas = () => {
 export const topbar = {
     config(opts) {
         for (const key in opts) {
-            if (options.hasOwnProperty(key)) {
+            if (Object.hasOwn(options, key)) {
                 // @ts-expect-error
                 options[key] = opts[key];
             }

package/dist/datetime/localDate.js

@@ -719,8 +719,13 @@ class LocalDateFactory {
         return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
     }
 }
-const localDateFactory = new LocalDateFactory();
-export const localDate = localDateFactory.fromInput.bind(localDateFactory);
-// The line below is the blackest of black magic I have ever written in 2024.
-// And probably 2023 as well.
-Object.setPrototypeOf(localDate, localDateFactory);
+// Built inside a function, so the whole construct can be marked pure and tree-shaken (see treeshake.test.ts)
+export const localDate = /* @__PURE__ */ createLocalDateFn();
+function createLocalDateFn() {
+    const localDateFactory = new LocalDateFactory();
+    const fn = localDateFactory.fromInput.bind(localDateFactory);
+    // The line below is the blackest of black magic I have ever written in 2024.
+    // And probably 2023 as well.
+    Object.setPrototypeOf(fn, localDateFactory);
+    return fn;
+}

package/dist/datetime/localTime.d.ts

@@ -257,10 +257,14 @@ declare class LocalTimeFactory {
     /**
      Convenience function to return current Unix timestamp in seconds.
      Like Date.now(), but in seconds.
+  
+     Import nowUnix from time.util.js in places where importing localTime is too heavy.
      */
     nowUnix(): UnixTimestamp;
     /**
      Convenience function that retuns the same as Date.now(), but with proper type of UnixTimestampMillis.
+  
+     Import nowUnixMillis from time.util.js in places where importing localTime is too heavy.
      */
     nowUnixMillis(): UnixTimestampMillis;
     /**

package/dist/datetime/localTime.js

@@ -2,7 +2,7 @@ import { comparators } from '../array/sort.js';
 import { _assert } from '../error/assert.js';
 import { Intl2 } from '../intl/intl.js';
 import { localDate } from './localDate.js';
-import { _ms } from './time.util.js';
+import { _ms, nowUnix, nowUnixMillis } from './time.util.js';
 // oxlint-disable-next-line import/no-cycle -- intentional cycle
 import { WallTime } from './wallTime.js';
 export var ISODayOfWeek;
@@ -676,15 +676,19 @@ class LocalTimeFactory {
     /**
      Convenience function to return current Unix timestamp in seconds.
      Like Date.now(), but in seconds.
+  
+     Import nowUnix from time.util.js in places where importing localTime is too heavy.
      */
     nowUnix() {
-        return Math.floor(Date.now() / 1000);
+        return nowUnix();
     }
     /**
      Convenience function that retuns the same as Date.now(), but with proper type of UnixTimestampMillis.
+  
+     Import nowUnixMillis from time.util.js in places where importing localTime is too heavy.
      */
     nowUnixMillis() {
-        return Date.now();
+        return nowUnixMillis();
     }
     /**
      * Create LocalTime from LocalTimeInput.
@@ -1027,8 +1031,13 @@ function getWallComponentsInTimezone(date, tz) {
     }
     return dto;
 }
-const localTimeFactory = new LocalTimeFactory();
-export const localTime = localTimeFactory.fromInput.bind(localTimeFactory);
-// The line below is the blackest of black magic I have ever written in 2024.
-// And probably 2023 as well.
-Object.setPrototypeOf(localTime, localTimeFactory);
+// Built inside a function, so the whole construct can be marked pure and tree-shaken (see treeshake.test.ts)
+export const localTime = /* @__PURE__ */ createLocalTimeFn();
+function createLocalTimeFn() {
+    const localTimeFactory = new LocalTimeFactory();
+    const fn = localTimeFactory.fromInput.bind(localTimeFactory);
+    // The line below is the blackest of black magic I have ever written in 2024.
+    // And probably 2023 as well.
+    Object.setPrototypeOf(fn, localTimeFactory);
+    return fn;
+}

package/dist/datetime/time.util.d.ts

@@ -1,4 +1,4 @@
-import type { NumberOfMilliseconds, UnixTimestampMillis } from '../types.js';
+import type { NumberOfMilliseconds, UnixTimestamp, UnixTimestampMillis } from '../types.js';
 /**
  * using _ = blockTimer()
  * // will log "took 1.234 sec" on dispose
@@ -23,3 +23,20 @@ export declare function _since(from: UnixTimestampMillis, until?: UnixTimestampM
  * 1h3m12s
  */
 export declare function _ms(millis: NumberOfMilliseconds): string;
+/**
+ * Can be used instead of `oxlint-disable ...` in places where Date is intentionally needed
+ */
+export declare function newDate(): Date;
+/**
+ Convenience function to return current Unix timestamp in seconds.
+ Like Date.now(), but in seconds.
+
+ Lives here rather than in localTime.ts, so importing it doesn't pull LocalTime into browser bundles.
+ */
+export declare function nowUnix(): UnixTimestamp;
+/**
+ Convenience function that retuns the same as Date.now(), but with proper type of UnixTimestampMillis.
+
+ Lives here rather than in localTime.ts, so importing it doesn't pull LocalTime into browser bundles.
+ */
+export declare function nowUnixMillis(): UnixTimestampMillis;

package/dist/datetime/time.util.js

@@ -8,7 +8,7 @@
  * @experimental
  */
 export function _blockTimer(name) {
-    const started = Date.now();
+    const started = nowUnixMillis();
     return {
         [Symbol.dispose]() {
             console.log(`${name ? name + ' ' : ''}took ${_since(started)}`);
@@ -18,7 +18,7 @@ export function _blockTimer(name) {
 /**
  * Returns time passed since `from` until `until` (default to Date.now())
  */
-export function _since(from, until = Date.now()) {
+export function _since(from, until = nowUnixMillis()) {
     return _ms(until - from);
 }
 /**
@@ -59,3 +59,29 @@ export function _ms(millis) {
     const days = Math.floor(hrs / 24);
     return `${days} days`;
 }
+/**
+ * Can be used instead of `oxlint-disable ...` in places where Date is intentionally needed
+ */
+export function newDate() {
+    // oxlint-disable-next-line no-restricted-globals -- the one sanctioned way to get a native Date
+    return new Date();
+}
+/**
+ Convenience function to return current Unix timestamp in seconds.
+ Like Date.now(), but in seconds.
+
+ Lives here rather than in localTime.ts, so importing it doesn't pull LocalTime into browser bundles.
+ */
+export function nowUnix() {
+    // oxlint-disable-next-line no-restricted-globals -- the one sanctioned way to read the clock
+    return Math.floor(Date.now() / 1000);
+}
+/**
+ Convenience function that retuns the same as Date.now(), but with proper type of UnixTimestampMillis.
+
+ Lives here rather than in localTime.ts, so importing it doesn't pull LocalTime into browser bundles.
+ */
+export function nowUnixMillis() {
+    // oxlint-disable-next-line no-restricted-globals -- the one sanctioned way to read the clock
+    return Date.now();
+}

package/dist/decorators/createPromiseDecorator.js

@@ -1,3 +1,4 @@
+import { nowUnixMillis } from '../datetime/time.util.js';
 import { _getTargetMethodSignature } from './decorator.util.js';
 /**
  * @example
@@ -19,7 +20,7 @@ export function _createPromiseDecorator(cfg, decoratorParams = {}) {
         const methodSignature = _getTargetMethodSignature(target, key);
         pd.value = async function (...args) {
             // console.log(`@${cfg.decoratorName} called inside function`)
-            const started = Date.now();
+            const started = nowUnixMillis();
             try {
                 // Before function
                 // console.log(`@${cfg.decoratorName} Before`)

package/dist/decorators/debounce.js

@@ -1,3 +1,4 @@
+import { nowUnixMillis } from '../datetime/time.util.js';
 import { _anyToError } from '../error/error.util.js';
 import { pDefer } from '../promise/pDefer.js';
 export function _debounce(func, wait, opt = {}) {
@@ -31,7 +32,7 @@ export function _debounce(func, wait, opt = {}) {
         return leading ? invokeFunc(time) : result;
     }
     function timerExpired() {
-        const time = Date.now();
+        const time = nowUnixMillis();
         if (shouldInvoke(time, state)) {
             trailingEdge(time);
             return;
@@ -58,13 +59,13 @@ export function _debounce(func, wait, opt = {}) {
         lastArgs = lastThis = timerId = undefined;
     }
     function flush() {
-        return timerId === undefined ? result : trailingEdge(Date.now());
+        return timerId === undefined ? result : trailingEdge(nowUnixMillis());
     }
     function pending() {
         return timerId !== undefined;
     }
     function debounced(...args) {
-        const time = Date.now();
+        const time = nowUnixMillis();
         const isInvoking = shouldInvoke(time, state);
         lastArgs = args;
         lastThis = this;
@@ -151,7 +152,7 @@ export function _asyncDebounce(func, wait, opt = {}) {
         return d;
     }
     function timerExpired() {
-        const time = Date.now();
+        const time = nowUnixMillis();
         if (shouldInvoke(time, state)) {
             void trailingEdge(time);
             return;
@@ -195,14 +196,14 @@ export function _asyncDebounce(func, wait, opt = {}) {
         }
         const d = deferred;
         cancelTimer(timerId);
-        await trailingEdge(Date.now());
+        await trailingEdge(nowUnixMillis());
         return d;
     }
     function pending() {
         return timerId !== undefined;
     }
     async function debounced(...args) {
-        const time = Date.now();
+        const time = nowUnixMillis();
         const isInvoking = shouldInvoke(time, state);
         lastArgs = args;
         lastThis = this;

package/dist/decorators/logMethod.decorator.js

@@ -1,4 +1,4 @@
-import { _ms } from '../datetime/time.util.js';
+import { _ms, nowUnixMillis } from '../datetime/time.util.js';
 import { _assert } from '../error/assert.js';
 import { consoleLogger } from '../log/commonLogger.js';
 import { SimpleMovingAverage } from '../math/sma.js';
@@ -35,7 +35,7 @@ export function _LogMethod(opt = {}) {
         const sma = avg ? new SimpleMovingAverage(avg) : undefined;
         let count = 0;
         descriptor.value = function (...args) {
-            const started = Date.now();
+            const started = nowUnixMillis();
             const ctx = this;
             // e.g `NameOfYourClass.methodName`
             // or `NameOfYourClass(instanceId).methodName`
@@ -72,7 +72,7 @@ export function _LogMethod(opt = {}) {
 }
 // oxlint-disable-next-line max-params
 function logFinished(logger, callSignature, started, sma, logResultFn, res, err) {
-    const millis = Date.now() - started;
+    const millis = nowUnixMillis() - started;
     const t = ['<<', callSignature, 'took', _ms(millis)];
     if (sma) {
         t.push(`(avg ${_ms(sma.pushGetAvg(millis))})`);

package/dist/enum.util.js

@@ -234,6 +234,7 @@ export function _numberEnumKeyOrUndefined(en, v) {
 export function _numberEnumKey(en, v) {
     const key = en[v];
     // This prevents passing a Key (not a Value) of enum here, which returns unexpected result (number, not string)
+    // oxlint-disable-next-line unicorn/prefer-type-error
     if (typeof key !== 'string')
         throw new Error(`_numberEnumKey not found for: ${v}`);
     return key;

package/dist/error/tryCatch.js

@@ -1,4 +1,4 @@
-import { _since } from '../datetime/time.util.js';
+import { _since, nowUnixMillis } from '../datetime/time.util.js';
 import { consoleLogger } from '../log/commonLogger.js';
 import { _anyToError } from './error.util.js';
 /**
@@ -13,7 +13,7 @@ export function _tryCatch(fn, opt = {}) {
     const { onError, logError = true, logSuccess = false, logger = consoleLogger } = opt;
     const fname = fn.name || 'anonymous';
     return async function (...args) {
-        const started = Date.now();
+        const started = nowUnixMillis();
         try {
             const r = await fn.apply(this, args);
             if (logSuccess) {

package/dist/http/fetcher.js

@@ -2,7 +2,7 @@
 /// <reference lib="dom" preserve="true" />
 /// <reference lib="dom.iterable" preserve="true" />
 import { abortSignalAnyOrUndefined, abortSignalTimeoutOrUndefined } from '../abort.js';
-import { _ms, _since } from '../datetime/time.util.js';
+import { _ms, _since, nowUnixMillis } from '../datetime/time.util.js';
 import { isServerSide } from '../env.js';
 import { _assert, _assertErrorClassOrRethrow, _assertIsError } from '../error/assert.js';
 import { _anyToError, _anyToErrorObject, _errorDataAppend, _errorLikeToErrorObject, HttpRequestError, UnexpectedPassError, } from '../error/error.util.js';
@@ -11,9 +11,10 @@ import { _clamp } from '../number/number.util.js';
 import { _filterFalsyValues, _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, _pick, } from '../object/object.util.js';
 import { pDelaySignal } from '../promise/pDelay.js';
 import { pTimeout } from '../promise/pTimeout.js';
-import { _toUrlOrNull } from '../string/index.js';
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util.js';
+import { _toUrlOrNull } from '../string/url.util.js';
 import { HTTP_METHODS } from './http.model.js';
+const FETCHER_VERSION = 5;
 /**
  * Experimental wrapper around Fetch.
  * Works in both Browser and Node, using `globalThis.fetch`.
@@ -25,16 +26,14 @@ export class Fetcher {
      *
      * Version is to be incremented every time a difference in behaviour (or a bugfix) is done.
      */
-    static VERSION = 5;
+    static VERSION = FETCHER_VERSION;
     /**
      * userAgent is statically exposed as Fetcher.userAgent.
      * It can be modified globally, and will be used (read) at the start of every request.
      */
-    static userAgent = isServerSide() ? `fetcher/${this.VERSION}` : undefined;
+    // Pure, and not reading `this.VERSION`, so bundlers can drop Fetcher when unused (see treeshake.test.ts)
+    static userAgent = /* @__PURE__ */ isServerSide() ? `fetcher/${FETCHER_VERSION}` : undefined;
     constructor(cfg = {}) {
-        if (typeof globalThis.fetch !== 'function') {
-            throw new TypeError('globalThis.fetch is not available');
-        }
         this.cfg = this.normalizeCfg(cfg);
         // Dynamically create all helper methods
         for (const method of HTTP_METHODS) {
@@ -184,7 +183,7 @@ export class Fetcher {
                 requestSignature: res.signature,
                 requestName: res.req.requestName,
                 fetcherName: this.cfg.name,
-                requestDuration: Date.now() - res.req.started,
+                requestDuration: nowUnixMillis() - res.req.started,
             });
         }
         const { data } = res.body;
@@ -314,7 +313,7 @@ export class Fetcher {
             signature,
         };
         while (!res.retryStatus.retryStopped) {
-            req.started = Date.now();
+            req.started = nowUnixMillis();
             res.body = undefined;
             req.init.signal = abortSignalAnyOrUndefined([
                 abortSignalTimeoutOrUndefined(timeoutMillis),
@@ -532,7 +531,7 @@ export class Fetcher {
             requestSignature: res.signature,
             requestName: res.req.requestName,
             fetcherName: this.cfg.name,
-            requestDuration: Date.now() - res.req.started,
+            requestDuration: nowUnixMillis() - res.req.started,
         }), {
             cause,
         });
@@ -609,16 +608,17 @@ export class Fetcher {
                     if (retryAfterNumber > 10 ** 9) {
                         // Value is too large to be a "seconds from now" delay,
                         // treat it as a UnixTimestamp instead (e.g GitHub sends `x-ratelimit-reset` like that)
-                        timeout = retryAfterNumber * 1000 - Date.now();
+                        timeout = retryAfterNumber * 1000 - nowUnixMillis();
                     }
                     else {
                         timeout = retryAfterNumber * 1000;
                     }
                 }
                 else {
+                    // oxlint-disable-next-line no-restricted-globals -- parses an HTTP-date, which localTime doesn't support
                     const date = new Date(retryAfterStr);
                     if (!Number.isNaN(date.getTime())) {
-                        timeout = date.getTime() - Date.now();
+                        timeout = date.getTime() - nowUnixMillis();
                     }
                 }
                 this.cfg.logger.log(`retry-after: ${retryAfterStr}`);
@@ -778,7 +778,7 @@ export class Fetcher {
                 'fetchFn',
                 'overrideFetchFn',
             ]),
-            started: Date.now(),
+            started: nowUnixMillis(),
             ..._omit(opt, ['method', 'headers', 'credentials']),
             inputUrl: opt.url || '',
             fullUrl: opt.url || '',

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export * from './bot.model.js';
 export * from './define.js';
 export * from './enum.util.js';
 export * from './env.js';
-export * from './env/buildInfo.js';
+export type * from './env/buildInfo.js';
 export * from './form.util.js';
 export * from './is.util.js';
 export * from './iter/asyncIterable2.js';

package/dist/index.js

@@ -4,7 +4,6 @@ export * from './bot.model.js';
 export * from './define.js';
 export * from './enum.util.js';
 export * from './env.js';
-export * from './env/buildInfo.js';
 export * from './form.util.js';
 export * from './is.util.js';
 export * from './iter/asyncIterable2.js';

package/dist/object/deepEquals.js

@@ -115,6 +115,7 @@ export function _deepJsonEquals(a, b) {
         a = undefined;
     }
     else if (a && typeof a === 'object') {
+        // oxlint-disable-next-line no-restricted-globals -- Date instances are compared by value
         if (a instanceof Date) {
             ;
             a = a.valueOf();
@@ -132,6 +133,7 @@ export function _deepJsonEquals(a, b) {
         b = undefined;
     }
     else if (b && typeof b === 'object') {
+        // oxlint-disable-next-line no-restricted-globals -- Date instances are compared by value
         if (b instanceof Date) {
             ;
             b = b.valueOf();

package/dist/object/keySortedMap.js

@@ -1,4 +1,4 @@
-import { _assert } from '../error/index.js';
+import { _assert } from '../error/assert.js';
 export class KeySortedMap {
     map;
     #sortedKeys;

package/dist/object/lazyKeySortedMap.js

@@ -1,4 +1,4 @@
-import { _assert } from '../error/index.js';
+import { _assert } from '../error/assert.js';
 export class LazyKeySortedMap {
     map;
     maybeSortedKeys;

package/dist/object/object.util.js

@@ -387,7 +387,7 @@ export function _unset(obj, prop) {
     if (!_isObject(obj)) {
         return;
     }
-    if (obj.hasOwnProperty(prop)) {
+    if (Object.hasOwn(obj, prop)) {
         delete obj[prop];
         return;
     }
@@ -512,7 +512,7 @@ export function _deepFreeze(o) {
     // Object.freeze — never assigns properties from one object to another.
     Object.freeze(o);
     Object.getOwnPropertyNames(o).forEach(prop => {
-        if (o.hasOwnProperty(prop) &&
+        if (Object.hasOwn(o, prop) &&
             o[prop] !== null &&
             (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
             !Object.isFrozen(o[prop])) {

package/dist/promise/pGradualQueue.js

@@ -1,3 +1,4 @@
+import { nowUnixMillis } from '../datetime/time.util.js';
 import { ErrorMode } from '../error/errorMode.js';
 import { createCommonLoggerAtLevel } from '../log/commonLogger.js';
 import { pDefer } from './pDefer.js';
@@ -34,7 +35,7 @@ export class PGradualQueue {
         // Fast-path: warmup complete
         if (this.warmupComplete)
             return this.cfg.concurrency;
-        const elapsed = Date.now() - this.startTime;
+        const elapsed = nowUnixMillis() - this.startTime;
         if (elapsed >= this.warmupMs) {
             this.warmupComplete = true;
             this.logger.debug('warmup complete');
@@ -51,7 +52,7 @@ export class PGradualQueue {
     async push(fn) {
         // Initialize start time on first push
         if (this.startTime === 0) {
-            this.startTime = Date.now();
+            this.startTime = nowUnixMillis();
         }
         const job = { fn, defer: pDefer() };
         const concurrency = this.getCurrentConcurrency();

package/dist/promise/pRetry.js

@@ -1,4 +1,4 @@
-import { _since } from '../datetime/time.util.js';
+import { _since, nowUnixMillis } from '../datetime/time.util.js';
 import { _errorDataAppend } from '../error/error.util.js';
 import { consoleLogger } from '../log/commonLogger.js';
 import { pDelay } from './pDelay.js';
@@ -26,7 +26,7 @@ export async function pRetry(fn, opt = {}) {
     let delay = initialDelay;
     let attempt = 0;
     while (true) {
-        const started = Date.now();
+        const started = nowUnixMillis();
         try {
             attempt++;
             if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {