@naturalcycles/js-lib 15.42.0 → 15.43.0

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

@@ -1,4 +1,4 @@
-import type { AbortablePredicate, FalsyValue, Mapper, Predicate, SortDirection, StringMap } from '../types.js';
+import type { AbortablePredicate, FalsyValue, Mapper, MutateOptions, Predicate, StringMap } from '../types.js';
 /**
  * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the
  * final chunk will be the remaining elements.
@@ -90,26 +90,6 @@ export declare function _mapBy<ITEM, KEY>(items: readonly ITEM[], mapper: Mapper
  * Returning `undefined` from the Mapper will EXCLUDE the item.
  */
 export declare function _groupBy<T>(items: readonly T[], mapper: Mapper<T, any>): StringMap<T[]>;
-export interface MutateOptions {
-    /**
-     * Defaults to false.
-     */
-    mutate?: boolean;
-}
-export interface SortOptions extends MutateOptions {
-    /**
-     * Defaults to 'asc'.
-     */
-    dir?: SortDirection;
-}
-/**
- * _sortBy([{age: 20}, {age: 10}], 'age')
- * // => [{age: 10}, {age: 20}]
- *
- * Same:
- * _sortBy([{age: 20}, {age: 10}], o => o.age)
- */
-export declare function _sortBy<T, COMPARE_TYPE extends string | number>(items: T[], mapper: Mapper<T, COMPARE_TYPE>, opt?: SortOptions): T[];
 /**
  * Similar to `Array.find`, but the `predicate` may return `END` to stop the iteration early.
  *

package/dist/array/array.util.js

@@ -151,29 +151,6 @@ export function _groupBy(items, mapper) {
     }
     return map;
 }
-/**
- * _sortBy([{age: 20}, {age: 10}], 'age')
- * // => [{age: 10}, {age: 20}]
- *
- * Same:
- * _sortBy([{age: 20}, {age: 10}], o => o.age)
- */
-export function _sortBy(items, mapper, opt = {}) {
-    const mod = opt.dir === 'desc' ? -1 : 1;
-    return (opt.mutate ? items : [...items]).sort((_a, _b) => {
-        // This implementation may call mapper more than once per item,
-        // but the benchmarks show no significant difference in performance.
-        const a = mapper(_a);
-        const b = mapper(_b);
-        // if (typeof a === 'number' && typeof b === 'number') return (a - b) * mod
-        // return String(a).localeCompare(String(b)) * mod
-        if (a > b)
-            return mod;
-        if (a < b)
-            return -mod;
-        return 0;
-    });
-}
 /**
  * Similar to `Array.find`, but the `predicate` may return `END` to stop the iteration early.
  *

package/dist/array/array2.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Better Array.
+ *
+ * @experimental
+ */
+export declare class Array2<T> extends Array<T> {
+    static of<T>(...items: T[]): Array2<T>;
+    get [Symbol.toStringTag](): string;
+    firstOrUndefined(): T | undefined;
+    first(): T;
+    lastOrUndefined(): T | undefined;
+    last(): T;
+    uniq(): Array2<T>;
+    shuffle(): Array2<T>;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+}

package/dist/array/array2.js

@@ -0,0 +1,44 @@
+import { _shuffle } from './array.util.js';
+/**
+ * Better Array.
+ *
+ * @experimental
+ */
+export class Array2 extends Array {
+    static of(...items) {
+        return new Array2(...items);
+    }
+    // eslint-disable-next-line @typescript-eslint/class-literal-property-style
+    get [Symbol.toStringTag]() {
+        return 'Array2';
+    }
+    firstOrUndefined() {
+        return this[0];
+    }
+    first() {
+        if (!this.length)
+            throw new Error('Array.first called on empty array');
+        return this[0];
+    }
+    lastOrUndefined() {
+        return this[this.length - 1];
+    }
+    last() {
+        const { length } = this;
+        if (!length)
+            throw new Error('Array.last called on empty array');
+        return this[length - 1];
+    }
+    uniq() {
+        return new Array2(...new Set(this));
+    }
+    shuffle() {
+        return new Array2(..._shuffle(this));
+    }
+    isEmpty() {
+        return this.length === 0;
+    }
+    isNotEmpty() {
+        return this.length !== 0;
+    }
+}

package/dist/array/index.d.ts

@@ -1,2 +1,6 @@
 export * from './array.util.js';
+export * from './array2.js';
 export * from './range.js';
+export * from './sort.js';
+export * from './sortedArray.js';
+export * from './sortedSet.js';

package/dist/array/index.js

@@ -1,2 +1,6 @@
 export * from './array.util.js';
+export * from './array2.js';
 export * from './range.js';
+export * from './sort.js';
+export * from './sortedArray.js';
+export * from './sortedSet.js';

package/dist/array/sort.d.ts

@@ -0,0 +1,51 @@
+import { type Comparator, type Mapper, type SortDirection, type SortOptions, type StringMap } from '../types.js';
+declare class Comparators {
+    /**
+     * Good for numbers.
+     */
+    numericAsc(a: number, b: number): number;
+    numericDesc(a: number, b: number): number;
+    localeAsc(a: string, b: string): number;
+    localeDesc(a: string, b: string): number;
+    by<T, COMPARE_TYPE extends string | number>(mapper: Mapper<T, COMPARE_TYPE>, opt?: ComparatorByOptions): Comparator<T>;
+    updatedAsc(a: {
+        updated: number;
+    }, b: {
+        updated: number;
+    }): number;
+    updatedDesc(a: {
+        updated: number;
+    }, b: {
+        updated: number;
+    }): number;
+    createdAsc(a: {
+        created: number;
+    }, b: {
+        created: number;
+    }): number;
+    createdDesc(a: {
+        created: number;
+    }, b: {
+        created: number;
+    }): number;
+}
+export declare const comparators: Comparators;
+interface ComparatorByOptions {
+    /**
+     * Defaults to 'asc'.
+     */
+    dir?: SortDirection;
+}
+/**
+ * _sortBy([{age: 20}, {age: 10}], 'age')
+ * // => [{age: 10}, {age: 20}]
+ *
+ * Same:
+ * _sortBy([{age: 20}, {age: 10}], o => o.age)
+ */
+export declare function _sortBy<T, COMPARE_TYPE extends string | number>(items: T[], mapper: Mapper<T, COMPARE_TYPE>, opt?: SortOptions): T[];
+/**
+ * Like _stringMapValues, but values are sorted.
+ */
+export declare function _stringMapValuesSorted<T>(map: StringMap<T>, mapper: Mapper<T, any>, dir?: SortDirection): T[];
+export {};

package/dist/array/sort.js

@@ -0,0 +1,61 @@
+import { _stringMapValues, } from '../types.js';
+class Comparators {
+    /**
+     * Good for numbers.
+     */
+    numericAsc(a, b) {
+        return a - b;
+    }
+    numericDesc(a, b) {
+        return b - a;
+    }
+    localeAsc(a, b) {
+        return a.localeCompare(b);
+    }
+    localeDesc(a, b) {
+        return -a.localeCompare(b);
+    }
+    by(mapper, opt = {}) {
+        const mod = opt.dir === 'desc' ? -1 : 1;
+        return (objA, objB) => {
+            // This implementation may call mapper more than once per item,
+            // but the benchmarks show no significant difference in performance.
+            const a = mapper(objA);
+            const b = mapper(objB);
+            if (a > b)
+                return mod;
+            if (a < b)
+                return -mod;
+            return 0;
+        };
+    }
+    updatedAsc(a, b) {
+        return a.updated - b.updated;
+    }
+    updatedDesc(a, b) {
+        return b.updated - a.updated;
+    }
+    createdAsc(a, b) {
+        return a.created - b.created;
+    }
+    createdDesc(a, b) {
+        return b.created - a.created;
+    }
+}
+export const comparators = new Comparators();
+/**
+ * _sortBy([{age: 20}, {age: 10}], 'age')
+ * // => [{age: 10}, {age: 20}]
+ *
+ * Same:
+ * _sortBy([{age: 20}, {age: 10}], o => o.age)
+ */
+export function _sortBy(items, mapper, opt = {}) {
+    return (opt.mutate ? items : [...items]).sort(comparators.by(mapper, opt));
+}
+/**
+ * Like _stringMapValues, but values are sorted.
+ */
+export function _stringMapValuesSorted(map, mapper, dir = 'asc') {
+    return _sortBy(_stringMapValues(map), mapper, { dir });
+}

package/dist/array/sortedArray.d.ts

@@ -0,0 +1,32 @@
+import type { Comparator } from '../types.js';
+import { Array2 } from './array2.js';
+export interface SortedArrayOptions<T> {
+    /**
+     * Defaults to undefined.
+     * Undefined (default comparator) works well for String keys.
+     * For Number keys - use comparators.numericAsc (or desc),
+     * otherwise sorting will be wrong (lexicographic).
+     */
+    comparator?: Comparator<T>;
+}
+/**
+ * Like Array, but keeps values sorted after every insertion.
+ */
+export declare class SortedArray<T> extends Array2<T> {
+    #private;
+    constructor(values?: Iterable<T>, opt?: SortedArrayOptions<T>);
+    push(...values: T[]): number;
+    unshift(...values: T[]): number;
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    static get [Symbol.species](): ArrayConstructor;
+    get [Symbol.toStringTag](): string;
+    private resort;
+}
+export declare class SortedStringArray extends SortedArray<string> {
+    constructor(values?: Iterable<string>);
+    get [Symbol.toStringTag](): string;
+}
+export declare class SortedNumberArray extends SortedArray<number> {
+    constructor(values?: Iterable<number>);
+    get [Symbol.toStringTag](): string;
+}

package/dist/array/sortedArray.js

@@ -0,0 +1,55 @@
+import { Array2 } from './array2.js';
+import { comparators } from './sort.js';
+/**
+ * Like Array, but keeps values sorted after every insertion.
+ */
+export class SortedArray extends Array2 {
+    constructor(values = [], opt = {}) {
+        super(...values);
+        this.#comparator = opt.comparator;
+        this.resort();
+    }
+    #comparator;
+    push(...values) {
+        const length = super.push(...values);
+        this.resort();
+        return length;
+    }
+    unshift(...values) {
+        const length = super.unshift(...values);
+        this.resort();
+        return length;
+    }
+    splice(start, deleteCount, ...items) {
+        const removed = super.splice(start, deleteCount ?? this.length - start, ...items);
+        if (items.length) {
+            this.resort();
+        }
+        return removed;
+    }
+    static get [Symbol.species]() {
+        return Array;
+    }
+    get [Symbol.toStringTag]() {
+        return 'Array';
+    }
+    resort() {
+        super.sort(this.#comparator);
+    }
+}
+export class SortedStringArray extends SortedArray {
+    constructor(values = []) {
+        super(values);
+    }
+    get [Symbol.toStringTag]() {
+        return 'Array';
+    }
+}
+export class SortedNumberArray extends SortedArray {
+    constructor(values = []) {
+        super(values, { comparator: comparators.numericAsc });
+    }
+    get [Symbol.toStringTag]() {
+        return 'Array';
+    }
+}

package/dist/array/sortedSet.d.ts

@@ -0,0 +1,22 @@
+import { Set2 } from '../object/index.js';
+import type { Comparator } from '../types.js';
+export interface SortedSetOptions<T> {
+    /**
+     * Defaults to undefined.
+     * Undefined (default comparator) works well for String keys.
+     * For Number keys - use comparators.numericAsc (or desc),
+     * otherwise sorting will be wrong (lexicographic).
+     */
+    comparator?: Comparator<T>;
+}
+/**
+ * Like Set, but keeps members sorted after every insertion.
+ */
+export declare class SortedSet<T> extends Set2<T> {
+    #private;
+    constructor(values?: Iterable<T>, opt?: SortedSetOptions<T>);
+    add(value: T): this;
+    addMany(items: Iterable<T>): this;
+    private recreate;
+    get [Symbol.toStringTag](): string;
+}

package/dist/array/sortedSet.js

@@ -0,0 +1,37 @@
+import { Set2 } from '../object/index.js';
+/**
+ * Like Set, but keeps members sorted after every insertion.
+ */
+export class SortedSet extends Set2 {
+    constructor(values = [], opt = {}) {
+        super();
+        this.#comparator = opt.comparator;
+        this.addMany(values);
+    }
+    #comparator;
+    add(value) {
+        if (super.has(value)) {
+            return this;
+        }
+        super.add(value);
+        return this.recreate();
+    }
+    addMany(items) {
+        for (const item of items) {
+            super.add(item);
+        }
+        return this.recreate();
+    }
+    recreate() {
+        const items = Array.from(super.values());
+        items.sort(this.#comparator);
+        super.clear();
+        for (const item of items) {
+            super.add(item);
+        }
+        return this;
+    }
+    get [Symbol.toStringTag]() {
+        return 'Set';
+    }
+}

package/dist/datetime/localDate.d.ts

@@ -1,6 +1,5 @@
-import type { MutateOptions, SortOptions } from '../array/array.util.js';
 import { Iterable2 } from '../iter/iterable2.js';
-import type { Inclusiveness, IsoDate, IsoDateTime, MonthId, UnixTimestamp, UnixTimestampMillis } from '../types.js';
+import type { Inclusiveness, IsoDate, IsoDateTime, MonthId, MutateOptions, SortOptions, UnixTimestamp, UnixTimestampMillis } from '../types.js';
 import type { DateObject, ISODayOfWeek, LocalTime } from './localTime.js';
 export type LocalDateUnit = LocalDateUnitStrict | 'week';
 export type LocalDateUnitStrict = 'year' | 'month' | 'day';

package/dist/datetime/localTime.d.ts

@@ -1,5 +1,4 @@
-import type { MutateOptions } from '../array/array.util.js';
-import type { IANATimezone, Inclusiveness, IsoDate, IsoDateTime, MonthId, NumberOfHours, NumberOfMinutes, SortDirection, UnixTimestamp, UnixTimestampMillis } from '../types.js';
+import type { IANATimezone, Inclusiveness, IsoDate, IsoDateTime, MonthId, MutateOptions, NumberOfHours, NumberOfMinutes, SortDirection, UnixTimestamp, UnixTimestampMillis } from '../types.js';
 import type { LocalDate } from './localDate.js';
 import { WallTime } from './wallTime.js';
 export type LocalTimeUnit = 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';

package/dist/json-schema/jsonSchemaBuilder.d.ts

@@ -19,7 +19,7 @@ export declare const j: {
     integer<T extends number = number>(): JsonSchemaNumberBuilder<T, false>;
     string<T extends string = string>(): JsonSchemaStringBuilder<T, false>;
     object: typeof object;
-    dbEntity<T extends AnyObject>(props: T): JsonSchemaObjectBuilder<BaseDBEntity & ({ [K in keyof T as T[K] extends JsonSchemaAnyBuilder<any, any, infer Opt extends boolean> ? Opt extends true ? never : K : never]: T[K] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never; } & { [K_1 in keyof T as T[K_1] extends JsonSchemaAnyBuilder<any, any, infer Opt extends boolean> ? Opt extends true ? K_1 : never : never]?: (T[K_1] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never) | undefined; } extends infer O ? { [K_2 in keyof O]: O[K_2]; } : never) extends infer O_1 ? { [K_3 in keyof O_1]: O_1[K_3]; } : never, false>;
+    dbEntity<P extends Record<string, JsonSchemaAnyBuilder<any, any, any>>>(props: P): JsonSchemaObjectBuilder<BaseDBEntity & { [K in keyof P]: P[K] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never; }>;
     rootObject<T extends AnyObject>(props: { [K in keyof T]: JsonSchemaAnyBuilder<T[K]>; }): JsonSchemaObjectBuilder<T, false>;
     array<T extends JsonSchemaAnyBuilder<any>>(itemSchema: T): JsonSchemaArrayBuilder<T["infer"], false>;
     tuple<T extends any[] = unknown[]>(items: JsonSchemaAnyBuilder[]): JsonSchemaTupleBuilder<T>;
@@ -139,12 +139,14 @@ export declare class JsonSchemaArrayBuilder<ITEM, Opt extends boolean = false> e
     constructor(itemsSchema: JsonSchemaBuilder<ITEM>);
     min(minItems: number): this;
     max(maxItems: number): this;
-    unique(uniqueItems: number): this;
+    unique(uniqueItems?: boolean): this;
 }
 export declare class JsonSchemaTupleBuilder<T extends any[]> extends JsonSchemaAnyBuilder<T, JsonSchemaTuple<T>> {
     constructor(items: JsonSchemaBuilder[]);
 }
-declare function object<P extends Record<string, JsonSchemaAnyBuilder<any, any, any>>>(props?: P): JsonSchemaObjectBuilder<{
+declare function object<P extends Record<string, JsonSchemaAnyBuilder<any, any, any>>>(props?: {
+    [K in keyof P]: P[K] & JsonSchemaAnyBuilder<any, any, any>;
+}): JsonSchemaObjectBuilder<{
     [K in keyof P as P[K] extends JsonSchemaAnyBuilder<any, any, infer Opt> ? Opt extends true ? never : K : never]: P[K] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never;
 } & {
     [K in keyof P as P[K] extends JsonSchemaAnyBuilder<any, any, infer Opt> ? Opt extends true ? K : never : never]?: P[K] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never;

package/dist/json-schema/jsonSchemaBuilder.js

@@ -392,7 +392,7 @@ export class JsonSchemaArrayBuilder extends JsonSchemaAnyBuilder {
         Object.assign(this.schema, { maxItems });
         return this;
     }
-    unique(uniqueItems) {
+    unique(uniqueItems = true) {
         Object.assign(this.schema, { uniqueItems });
         return this;
     }

package/dist/log/commonLogger.d.ts

@@ -1,4 +1,4 @@
-import type { MutateOptions } from '../array/array.util.js';
+import type { MutateOptions } from '../types.js';
 /**
  * These levels follow console.* naming,
  * so you can use console[level] safely.

package/dist/math/math.util.js

@@ -1,5 +1,5 @@
+import { comparators } from '../array/sort.js';
 import { _assert } from '../error/assert.js';
-import { _sortNumbers } from '../number/number.util.js';
 /**
  * @returns Average of the array of numbers
  *
@@ -46,7 +46,7 @@ export function _averageWeighted(values, weights) {
  * // 3
  */
 export function _percentile(values, pc) {
-    const sorted = _sortNumbers(values);
+    const sorted = values.sort(comparators.numericAsc);
     // Floating pos in the range of [0; length - 1]
     const pos = ((values.length - 1) * pc) / 100;
     const dec = pos % 1;
@@ -59,7 +59,7 @@ export function _percentile(values, pc) {
  */
 export function _percentiles(values, pcs) {
     const r = {};
-    const sorted = _sortNumbers(values);
+    const sorted = values.sort(comparators.numericAsc);
     for (const pc of pcs) {
         // Floating pos in the range of [0; length - 1]
         const pos = ((values.length - 1) * pc) / 100;

package/dist/number/number.util.d.ts

@@ -1,4 +1,3 @@
-import type { SortOptions } from '../array/array.util.js';
 import type { Inclusiveness } from '../types.js';
 export declare function _randomInt(minIncl: number, maxIncl: number): number;
 /**
@@ -29,16 +28,6 @@ export declare function _runLessOften(percent: number): boolean;
  */
 export declare function _isBetween<T extends number | string>(x: T, min: T, max: T, incl: Inclusiveness): boolean;
 export declare function _clamp(x: number, minIncl: number, maxIncl: number): number;
-/**
- * This function exists, because in JS you cannot just .sort() numbers,
- * as .sort() function first maps everything to String.
- *
- * @example
- *
- * _sortNumbers([1, 3, 2])
- * // [1, 2, 3]
- */
-export declare function _sortNumbers(numbers: number[], opt?: SortOptions): number[];
 /**
  * Same as .toFixed(), but conveniently casts the output to Number.
  *

package/dist/number/number.util.js

@@ -43,19 +43,6 @@ export function _clamp(x, minIncl, maxIncl) {
     // oxlint-disable-next-line unicorn/prefer-math-min-max
     return x <= minIncl ? minIncl : x >= maxIncl ? maxIncl : x;
 }
-/**
- * This function exists, because in JS you cannot just .sort() numbers,
- * as .sort() function first maps everything to String.
- *
- * @example
- *
- * _sortNumbers([1, 3, 2])
- * // [1, 2, 3]
- */
-export function _sortNumbers(numbers, opt = {}) {
-    const mod = opt.dir === 'desc' ? -1 : 1;
-    return (opt.mutate ? numbers : [...numbers]).sort((a, b) => (a - b) * mod);
-}
 /**
  * Same as .toFixed(), but conveniently casts the output to Number.
  *

package/dist/object/keySortedMap.d.ts

@@ -1,10 +1,12 @@
-export interface KeySortedMapOptions {
+import type { Comparator } from '../types.js';
+export interface KeySortedMapOptions<K> {
     /**
-     * Defaults to false.
-     * Set to true if your keys are numeric,
-     * so it would sort correctly.
+     * Defaults to undefined.
+     * Undefined (default comparator) works well for String keys.
+     * For Number keys - use comparators.numericAsc (or desc),
+     * otherwise sorting will be wrong (lexicographic).
      */
-    numericKeys?: boolean;
+    comparator?: Comparator<K>;
 }
 /**
  * Maintains sorted array of keys.
@@ -18,10 +20,10 @@ export interface KeySortedMapOptions {
  * @experimental
  */
 export declare class KeySortedMap<K, V> implements Map<K, V> {
-    opt: KeySortedMapOptions;
+    opt: KeySortedMapOptions<K>;
     private readonly map;
     private readonly sortedKeys;
-    constructor(entries?: [K, V][], opt?: KeySortedMapOptions);
+    constructor(entries?: [K, V][], opt?: KeySortedMapOptions<K>);
     /**
      * Convenience way to create KeySortedMap from object.
      */

package/dist/object/keySortedMap.js

@@ -190,16 +190,6 @@ export class KeySortedMap {
         return lo;
     }
     sortKeys() {
-        if (this.opt.numericKeys) {
-            ;
-            this.sortedKeys.sort(numericAscCompare);
-        }
-        else {
-            // Default sort - fastest for Strings
-            this.sortedKeys.sort();
-        }
+        this.sortedKeys.sort(this.opt.comparator);
     }
 }
-function numericAscCompare(a, b) {
-    return a - b;
-}

package/dist/object/object.util.d.ts

@@ -1,5 +1,4 @@
-import type { MutateOptions } from '../array/array.util.js';
-import type { AnyObject, KeyValueTuple, ObjectMapper, ObjectPredicate, Reviver, StringMap, ValueOf } from '../types.js';
+import type { AnyObject, KeyValueTuple, MutateOptions, ObjectMapper, ObjectPredicate, Reviver, StringMap, ValueOf } from '../types.js';
 import { SKIP } from '../types.js';
 /**
  * Returns clone of `obj` with only `props` preserved.

package/dist/object/set2.d.ts

@@ -6,11 +6,15 @@
  * @experimental
  */
 export declare class Set2<T = any> extends Set<T> {
+    static of<T>(items?: Iterable<T> | null): Set2<T>;
     /**
      * Like .add(), but allows to add multiple items at once.
      * Mutates the Set, but also returns it conveniently.
      */
     addMany(items: Iterable<T>): this;
+    first(): T;
+    firstOrUndefined(): T | undefined;
     toArray(): T[];
     toJSON(): T[];
+    get [Symbol.toStringTag](): string;
 }

package/dist/object/set2.js

@@ -6,6 +6,9 @@
  * @experimental
  */
 export class Set2 extends Set {
+    static of(items) {
+        return new Set2(items);
+    }
     /**
      * Like .add(), but allows to add multiple items at once.
      * Mutates the Set, but also returns it conveniently.
@@ -16,10 +19,23 @@ export class Set2 extends Set {
         }
         return this;
     }
+    first() {
+        if (!this.size)
+            throw new Error('Set.first called on empty set');
+        return this.firstOrUndefined();
+    }
+    firstOrUndefined() {
+        return this.values().next().value;
+    }
+    // Last is not implemented, because it requires to traverse the whole Set - not optimal
+    // last(): T {
     toArray() {
         return [...this];
     }
     toJSON() {
         return [...this];
     }
+    get [Symbol.toStringTag]() {
+        return 'Set';
+    }
 }

package/dist/semver.d.ts

@@ -1,4 +1,4 @@
-import type { SortOptions } from './array/array.util.js';
+import type { SortOptions } from './types.js';
 export type SemverInput = string | Semver;
 export type SemverInputNullable = SemverInput | null | undefined;
 export type SemverTokens = [major: number, minor: number, patch: number];