@zoodogood/utils 4.0.0-change.2617 → 4.2.1-change.3358

package/lib/objectives/BusyNumeric.d.ts

@@ -6,10 +6,12 @@
  * 2) Хотя у нас есть список занятых номеров, у нас не может быть списка свободных (за условием задачи)
  * Этот алгоритм используется для эффективного поиска тех самых свободных номеров, которые удовлетворяют заданному условию
  */
+export declare function size_of_area(area: readonly [number, number]): number;
 export declare class BusyNumeric {
     #private;
     readonly range: number;
     readonly busy_areas: (readonly [number, number])[];
+    free_area: number;
     get peak_start_busy(): boolean;
     get peak_end_busy(): boolean;
     constructor(range: number);

package/lib/objectives/BusyNumeric.js

@@ -26,6 +26,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 var _BusyNumeric_peak_start_busy, _BusyNumeric_peak_end_busy;
+import assert from "node:assert";
 import { binary_search } from "../primitives/binary_search.js";
 /**
  * MARK: Представьте отель
@@ -39,6 +40,9 @@ import { binary_search } from "../primitives/binary_search.js";
 // Если основное количество производительности не реализуется из-за особенностей структуры списка, то это можно оптимизировать
 // Интересно что ветки дерева можно определять по индексу. Да, это интересное замечание.
 // В BusyNumeric можно добавить ещё метод separate
+export function size_of_area(area) {
+    return area[1] - area[0] + 1;
+}
 export class BusyNumeric {
     get peak_start_busy() {
         var _a;
@@ -77,10 +81,9 @@ export class BusyNumeric {
                 this.refresh._peak();
             },
         };
-        if (range <= 0) {
-            throw new Error("Assertion: range must be positive");
-        }
+        assert(range > 0, "Range must be positive");
         this.range = range;
+        this.free_area = this.range + /* includes position 0 */ 1;
     }
     bifurcate(point) {
         this.insert_area(point, point);
@@ -118,34 +121,32 @@ export class BusyNumeric {
         return { size, left, right };
     }
     insert_area(start, end) {
-        if (!Number.isInteger(start) || !Number.isInteger(end)) {
-            throw new Error(`Assertion error: start or end not integer ${start} ${end}, maybe float?`);
-        }
+        assert(Number.isInteger(start) && Number.isInteger(end), `Assertion error: start or end not integer ${start} ${end}, maybe float?`);
         if (start > end) {
             [start, end] = [end, start];
         }
-        if (start < 0) {
-            throw new Error("Assertion error: start < 0");
-        }
-        if (end > this.range) {
-            throw new Error("Assertion error: end > this.range");
-        }
-        const place_index = binary_search(this.busy_areas.length - 1, (index) => {
-            var _a, _b, _c;
-            const value = (_a = this.busy_areas[index]) === null || _a === void 0 ? void 0 : _a[1];
-            const biggest = end < value;
-            if (biggest) {
-                return 1;
-            }
-            return (+(((_c = (_b = this.busy_areas[index + 1]) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : Number.MAX_SAFE_INTEGER) > end) - 1);
-        }) + 1;
+        assert(start >= 0);
+        assert(end <= this.range);
+        const place_index = this.busy_areas.length
+            ? binary_search(this.busy_areas.length - 1, (index) => {
+                var _a, _b, _c;
+                const value = (_a = this.busy_areas[index]) === null || _a === void 0 ? void 0 : _a[1];
+                const biggest = end < value;
+                if (biggest) {
+                    return 1 /* BinarySearchCompareSpec.Biggest */;
+                }
+                return (+(((_c = (_b = this.busy_areas[index + 1]) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : Number.MAX_SAFE_INTEGER) > end) - 1);
+            }) + 1
+            : 0;
         const left = this.busy_areas[place_index - 1];
         const right = this.busy_areas[place_index];
         const is_left_included = !!left && left[1] + 1 >= start;
         const is_right_included = !!right && right[0] - 1 <= end;
         // Merge strategy 3
         if (is_left_included && is_right_included) {
-            this.busy_areas.splice(place_index - 1, 2, [left[0], right[1]]);
+            const points = [left[0], right[1]];
+            this.free_area -= size_of_area(points) - size_of_area(left) - size_of_area(right);
+            this.busy_areas.splice(place_index - 1, 2, points);
             return;
         }
         // Merge strategy 2
@@ -154,13 +155,13 @@ export class BusyNumeric {
             const [index, points] = is_left_included
                 ? [place_index - 1, [target[0], end]]
                 : [place_index, [start, target[1]]];
-            if (target[0] <= start && target[1] >= end) {
-                throw new Error("Assertion error: [start, end] in range");
-            }
+            assert(!(target[0] <= start && target[1] >= end), "Assertion error: [start, end] in range");
+            this.free_area -= size_of_area(points) - size_of_area(target);
             this.busy_areas.splice(index, 1, points);
             return;
         }
         // Merge strategy 1
+        this.free_area -= size_of_area([start, end]);
         this.busy_areas.splice(place_index, 0, [start, end]);
     }
 }

package/lib/objectives/LazySort/LazySort.build.d.ts

@@ -0,0 +1,53 @@
+type Predicate<T> = (T: T, index: number, array: T[]) => boolean;
+export declare const enum ArrayEmulateStrategy {
+    Partial = 0,
+    Proxied = 1
+}
+interface Configuration {
+    chunks_count?: number;
+    revert?: boolean;
+    emulate?: ArrayEmulateStrategy;
+}
+type Chunk<T> = LazySort<T>;
+type WithValue<T> = [T, number];
+export declare class LazySort<T> {
+    #private;
+    emulate: ArrayEmulateStrategy;
+    revert: boolean;
+    chunks_count: number;
+    iterable: WithValue<T>[];
+    length: number;
+    calculated: boolean;
+    is_atomic?: boolean;
+    max?: number;
+    min?: number;
+    chunk_range?: number;
+    chunks?: Chunk<T>[];
+    chunk_thresholds?: number[];
+    static ofNumbers(numbers: number[]): LazySort<number>;
+    static ofArrayMapValue<T>(array: T[], valueOf: (T: T, index: number, arr: T[]) => T): LazySort<T>;
+    constructor(iterable1: WithValue<T>[], { revert: revert1, chunks_count: chunks_count1, emulate: emulate1 }?: Configuration);
+    get atomic_chunk_arr(): WithValue<T>[];
+    chunks_update_thresholds_after(chunk_index: number, diff: number): number[];
+    entry(): LazySortEntry<T>;
+}
+export declare class LazySortEntry<T> extends Array {
+    #private;
+    constructor(source: LazySort<T>);
+    entry(): this;
+    get length(): number;
+    set length(value: number);
+    [Symbol.iterator](): Generator<WithValue<T>>;
+    toArray(): WithValue<T>[];
+    at(at: number): WithValue<T> | undefined;
+    positive_at(at: number): (WithValue<T> | undefined);
+    find(predicate: Predicate<WithValue<T>>): WithValue<T> | undefined;
+    findIndex(predicate: Predicate<WithValue<T>>): number;
+    findLast(predicate: Predicate<WithValue<T>>): WithValue<T> | undefined;
+    findIndexLast(predicate: Predicate<WithValue<T>>): number;
+    indexOf(item: WithValue<T>): number;
+    some(predicate: Predicate<WithValue<T>>): boolean;
+    every(predicate: Predicate<WithValue<T>>): boolean;
+    splice(start: number, deleteCount: number, ...items: WithValue<T>[]): WithValue<T>[];
+}
+export {};

package/lib/objectives/LazySort/LazySort.build.js

@@ -0,0 +1,234 @@
+// Декларации:
+// Утверждаю: Атомик всегда отсортирован
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _LazySort_instances, _LazySort_to_proxied_array_emulator, _LazySort_to_partial_array_emulator, _LazySortEntry_source;
+var concatAssign = (lhs, rhs) => { var _a; return (((_a = rhs === null || rhs === void 0 ? void 0 : rhs[Symbol.isConcatSpreadable]) !== null && _a !== void 0 ? _a : Array.isArray(rhs)) ? lhs.push.apply(lhs, rhs) : lhs.push(rhs), lhs); };
+import assert from "node:assert";
+const GOOD_CHUNKS_COUNT = 11;
+export class LazySort {
+    static ofNumbers(numbers) {
+        return new this(numbers.map($1 => [$1, $1]));
+    }
+    static ofArrayMapValue(array, valueOf) {
+        return new this(array.map(($, i, arr) => [$, valueOf($, i, arr)]));
+    }
+    constructor(iterable1, { revert: revert1 = false, chunks_count: chunks_count1 = GOOD_CHUNKS_COUNT, emulate: emulate1 = 0 /* ArrayEmulateStrategy.Partial */ } = {}) {
+        _LazySort_instances.add(this);
+        this.calculated = false;
+        this.iterable = iterable1;
+        this.revert = revert1;
+        this.chunks_count = chunks_count1;
+        this.emulate = emulate1;
+        assert(this.chunks_count >= 2);
+        this.length = this.iterable.length;
+    }
+    get atomic_chunk_arr() {
+        return this.chunks[0].iterable;
+    }
+    chunks_update_thresholds_after(chunk_index, diff) {
+        const results = [];
+        for (let end1 = this.chunk_thresholds.length, i1 = chunk_index; i1 < end1; ++i1) {
+            const index = i1;
+            results.push(this.chunk_thresholds[index] += diff);
+        }
+        ;
+        return results;
+    }
+    entry() {
+        var _a, _b;
+        if (!this.calculated) {
+            const max1 = Math.max(...this.iterable.map($2 => $2[1]));
+            this.max = max1;
+            const min1 = Math.min(...this.iterable.map($3 => $3[1]));
+            this.min = min1;
+            const chunk_range1 = Math.ceil((this.max - this.min) / (this.chunks_count - 1));
+            this.chunk_range = chunk_range1;
+            this.is_atomic = ((this.chunks_count >= this.length) || (this.max - this.min === 0));
+            const chunks1 = (() => {
+                if (!this.is_atomic) {
+                    const chunks = [...new Array(this.chunks_count)].map(() => []);
+                    this.iterable.forEach((x) => {
+                        return chunks[Math.floor((x[1] - this.min) / this.chunk_range)].push(x);
+                    });
+                    return chunks.map($4 => new LazySort($4, { revert: this.revert, chunks_count: this.chunks_count, emulate: this.emulate }));
+                }
+                else {
+                    return [new LazySort(this.iterable.toSorted((a, b) => (-1) ** +this.revert * (a[1] - b[1])), { revert: this.revert, chunks_count: this.chunks_count, emulate: this.emulate })];
+                }
+            })();
+            this.chunks = chunks1;
+            this.revert && ((_a = this.chunks) === null || _a === void 0 ? void 0 : _a.reverse());
+            const chunk_thresholds1 = (_b = this.chunks) === null || _b === void 0 ? void 0 : _b.reduce((acc, next) => acc.concat([(acc[acc.length - 1] || 0) + next.length]), []);
+            this.chunk_thresholds = chunk_thresholds1;
+        }
+        this.calculated = true;
+        switch (this.emulate) {
+            case 0 /* ArrayEmulateStrategy.Partial */: {
+                return __classPrivateFieldGet(this, _LazySort_instances, "m", _LazySort_to_partial_array_emulator).call(this);
+            }
+            case 1 /* ArrayEmulateStrategy.Proxied */: {
+                return __classPrivateFieldGet(this, _LazySort_instances, "m", _LazySort_to_proxied_array_emulator).call(this);
+            }
+        }
+    }
+}
+_LazySort_instances = new WeakSet(), _LazySort_to_proxied_array_emulator = function _LazySort_to_proxied_array_emulator() {
+    const instance = __classPrivateFieldGet(this, _LazySort_instances, "m", _LazySort_to_partial_array_emulator).call(this);
+    return instance;
+}, _LazySort_to_partial_array_emulator = function _LazySort_to_partial_array_emulator() {
+    return new LazySortEntry(this);
+};
+export class LazySortEntry extends Array {
+    constructor(source) {
+        super();
+        _LazySortEntry_source.set(this, void 0);
+        __classPrivateFieldSet(this, _LazySortEntry_source, source, "f");
+    }
+    entry() {
+        return this;
+    }
+    get length() {
+        return __classPrivateFieldGet(this, _LazySortEntry_source, "f").length;
+    }
+    set length(value) {
+        let ref;
+        ((ref = this.toArray()).length = value, ref);
+    }
+    *[(_LazySortEntry_source = new WeakMap(), Symbol.iterator)]() {
+        for (let end2 = __classPrivateFieldGet(this, _LazySortEntry_source, "f").length, i2 = 0; i2 < end2; ++i2) {
+            const index = i2;
+            yield this.positive_at(index);
+        }
+    }
+    toArray() {
+        if (__classPrivateFieldGet(this, _LazySortEntry_source, "f").is_atomic) {
+            return __classPrivateFieldGet(this, _LazySortEntry_source, "f").atomic_chunk_arr;
+        }
+        return __classPrivateFieldGet(this, _LazySortEntry_source, "f").chunks.map($5 => $5.entry().toArray()).flat();
+    }
+    at(at) {
+        return at < 0 ? this.positive_at(__classPrivateFieldGet(this, _LazySortEntry_source, "f").length - at) : this.positive_at(at);
+    }
+    positive_at(at) {
+        if (__classPrivateFieldGet(this, _LazySortEntry_source, "f").is_atomic) {
+            return __classPrivateFieldGet(this, _LazySortEntry_source, "f").atomic_chunk_arr[at];
+        }
+        const chunk_index = __classPrivateFieldGet(this, _LazySortEntry_source, "f").chunk_thresholds.findIndex((a1 => a1 > at));
+        if (chunk_index === -1) {
+            return undefined;
+        }
+        const chunk = __classPrivateFieldGet(this, _LazySortEntry_source, "f").chunks[chunk_index];
+        return chunk.entry().positive_at(at - (__classPrivateFieldGet(this, _LazySortEntry_source, "f").chunk_thresholds[chunk_index - 1] || 0));
+    }
+    find(predicate) {
+        return this.positive_at(this.findIndex(predicate));
+    }
+    findIndex(predicate) {
+        for (let end3 = this.length, i3 = 0; i3 < end3; ++i3) {
+            const index = i3;
+            if (predicate(this.positive_at(index), index, this)) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    findLast(predicate) {
+        return this.positive_at(this.findIndexLast(predicate));
+    }
+    findIndexLast(predicate) {
+        for (let i4 = this.length + -1; i4 >= 0; --i4) {
+            const index = i4;
+            if (predicate(this.positive_at(index), index, this)) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    indexOf(item) {
+        if (__classPrivateFieldGet(this, _LazySortEntry_source, "f").is_atomic) {
+            return __classPrivateFieldGet(this, _LazySortEntry_source, "f").atomic_chunk_arr.indexOf(item);
+        }
+        let results1;
+        results1 = [];
+        let ref1;
+        for (const chunk_index in ref1 = __classPrivateFieldGet(this, _LazySortEntry_source, "f").chunks) {
+            const chunk = ref1[chunk_index];
+            let ref2;
+            if ((ref2 = chunk.entry().indexOf(item))) {
+                const index = ref2;
+                results1 = [index, +chunk_index];
+                break;
+            }
+            else {
+                results1.push(void 0);
+            }
+        }
+        ;
+        const [index, chunk_index] = results1;
+        if (chunk_index === undefined) {
+            return -1;
+        }
+        return (__classPrivateFieldGet(this, _LazySortEntry_source, "f").chunk_thresholds[chunk_index - 1] || 0) + index;
+    }
+    some(predicate) {
+        return (this.findIndex(predicate)) !== -1;
+    }
+    // @ts-expect-error
+    every(predicate) {
+        return !this.some(predicate);
+    }
+    splice(start, deleteCount, ...items) {
+        start < 0 && (start = __classPrivateFieldGet(this, _LazySortEntry_source, "f").length + start);
+        (start + deleteCount > __classPrivateFieldGet(this, _LazySortEntry_source, "f").length) && (deleteCount = __classPrivateFieldGet(this, _LazySortEntry_source, "f").length - start);
+        (deleteCount - items.length !== 0) && (__classPrivateFieldGet(this, _LazySortEntry_source, "f").length -= (deleteCount - items.length));
+        if (__classPrivateFieldGet(this, _LazySortEntry_source, "f").is_atomic) {
+            return __classPrivateFieldGet(this, _LazySortEntry_source, "f").atomic_chunk_arr.splice(start, deleteCount, ...items);
+        }
+        const end = start + deleteCount;
+        const removed = [];
+        const ret = removed;
+        __classPrivateFieldGet(this, _LazySortEntry_source, "f").chunks
+            .map((chunk, chunk_index) => {
+            return ({
+                chunk_start: __classPrivateFieldGet(this, _LazySortEntry_source, "f").chunk_thresholds[chunk_index - 1] || 0,
+                chunk_end: __classPrivateFieldGet(this, _LazySortEntry_source, "f").chunk_thresholds[chunk_index],
+                chunk,
+                chunk_index
+            });
+        })
+            .filter(({ chunk_start, chunk_end, chunk }) => {
+            if (!chunk.length) {
+                return false;
+            }
+            return start < chunk_end && chunk_start <= end;
+        })
+            .forEach(({ chunk_start, chunk_end, chunk_index, chunk }, changed_index, changes_array) => {
+            const replace_start = changed_index === 0
+                ? start - chunk_start
+                : 0;
+            const replace_end = changed_index === changes_array.length - 1
+                ? end - chunk_start
+                : chunk.length;
+            const _removed_count = replace_end - replace_start;
+            const _added_items = items.slice(replace_start + chunk_start - start, changed_index === changes_array.length - 1 ? undefined : replace_end + chunk_start - start);
+            __classPrivateFieldGet(this, _LazySortEntry_source, "f").chunks_update_thresholds_after(chunk_index, _added_items.length - _removed_count);
+            return concatAssign(removed, chunk.entry().splice(replace_start, _removed_count, ..._added_items));
+        });
+        return ret;
+    }
+}
+// slice()
+// push()
+// pop()
+// unshift()
+// shift()

package/lib/objectives/LazySort/LazySort.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/objectives/getRandomElementFromArray.d.ts

@@ -5,7 +5,9 @@ interface IParams<T> {
     filter?: (item: T) => boolean;
 }
 interface IPickContext<T> {
-    busy_preventable: ReturnType<typeof create_default_preventable>;
+    busy_preventable: ReturnType<typeof create_default_preventable> & {
+        require_insert(): void;
+    };
     item: T;
     pick: (context: IPickContext<T>) => boolean;
     threshold: number;
@@ -22,6 +24,8 @@ export declare class RandomizerContext<T> {
     }): RandomizerContext<T>;
     pickRandom(pick?: IPickContext<T>["pick"]): T | undefined;
 }
+export declare function pickInThresholds(thresholds: number[], value: number): number;
+export declare function thresholdsOf(weights: NonNullable<IParams<unknown>["associatedWeights"]>): number[];
 export declare function getRandomElementIndexInWeights(weights: NonNullable<IParams<unknown>["associatedWeights"]>): number | never;
-export declare function getRandomElementFromArray<T>(array: T[], { associatedWeights, filter }?: IParams<T>): void;
+export declare function getRandomElementFromArray<T>(array: T[], { associatedWeights, filter }?: IParams<T>): T | undefined;
 export {};

package/lib/objectives/getRandomElementFromArray.js

@@ -1,57 +1,74 @@
+import assert from "node:assert";
 import { binary_search } from "../primitives/binary_search.js";
 import { create_default_preventable } from "../primitives/createDefaultPreventable.js";
-import { BusyNumeric } from "./BusyNumeric.js";
+import { BusyNumeric, size_of_area } from "./BusyNumeric.js";
 import { getRandomNumberInRange } from "./getRandomNumberInRange.js";
 export class RandomizerContext {
     constructor(array, thresholds) {
         var _a;
         this.array = array;
         this.thresholds = thresholds;
-        const range = (_a = thresholds === null || thresholds === void 0 ? void 0 : thresholds.at(-1)) !== null && _a !== void 0 ? _a : array.length;
+        const range = (_a = thresholds === null || thresholds === void 0 ? void 0 : thresholds.at(-1)) !== null && _a !== void 0 ? _a : array.length - 1;
         this.hotel = new BusyNumeric(range);
     }
     static from({ array, associatedWeights, }) {
-        const thresholds = associatedWeights &&
-            _getRandomElementIndexInWeight_thresholds(associatedWeights);
+        const thresholds = associatedWeights && thresholdsOf(associatedWeights);
         return new RandomizerContext(array, thresholds);
     }
     pickRandom(pick = () => true) {
-        var _a;
         const { hotel, thresholds, array } = this;
         while (true) {
             const segments_count = hotel.segments_count();
             if (!segments_count) {
                 break;
             }
-            const { left, size } = hotel.segment(getRandomNumberInRange({ max: segments_count - 1 }));
-            const point = ((_a = left === null || left === void 0 ? void 0 : left[1]) !== null && _a !== void 0 ? _a : -1) + getRandomNumberInRange({ min: 1, max: size });
-            const index = thresholds
-                ? _getRandomElementIndexInWeight_of_thresholds(thresholds, point)
-                : point;
+            const target_of_free = getRandomNumberInRange({ max: hotel.free_area - 1 });
+            const position = (() => {
+                var _a, _b, _c, _d;
+                let segment = 0;
+                let distance = target_of_free;
+                let position = 0;
+                while (true) {
+                    const free_area = ((_b = (_a = hotel.busy_areas[segment]) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : hotel.range + 1) - ((_d = (_c = hotel.busy_areas[segment - 1]) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : -1) - 1;
+                    distance -= free_area;
+                    position += free_area;
+                    if (distance < 0) {
+                        return position + distance;
+                    }
+                    position += size_of_area(hotel.busy_areas[segment] || [0, hotel.range + 1]);
+                    segment++;
+                }
+            })();
+            let _require_insert = false;
+            const index = thresholds ? pickInThresholds(thresholds, position) : position;
             const element = array[index];
             const pickContext = {
-                busy_preventable: create_default_preventable(),
+                busy_preventable: {
+                    ...create_default_preventable(),
+                    require_insert() {
+                        _require_insert = true;
+                    }
+                },
                 item: element,
                 pick,
                 threshold: index,
-                point,
+                point: position,
             };
-            if (pick(pickContext)) {
-                return element;
-            }
-            if (!pickContext.busy_preventable.default_prevented()) {
+            const picked = pick(pickContext);
+            if (_require_insert || !picked && !pickContext.busy_preventable.default_prevented()) {
                 thresholds
                     ? hotel.insert_area(thresholds[index - 1] + 1 || 0, thresholds[index])
                     : hotel.bifurcate(index);
             }
+            if (picked) {
+                return element;
+            }
         }
         return undefined;
     }
 }
-function _getRandomElementIndexInWeight_of_thresholds(thresholds, value) {
-    if (!thresholds.length) {
-        return -1;
-    }
+export function pickInThresholds(thresholds, value) {
+    assert(thresholds.length > 0);
     return binary_search(thresholds.length - 1, (index) => {
         var _a;
         const hold = thresholds[index];
@@ -64,17 +81,15 @@ function _getRandomElementIndexInWeight_of_thresholds(thresholds, value) {
         return 1;
     });
 }
-function _getRandomElementIndexInWeight_thresholds(weights) {
-    if (weights.length < 1) {
-        new Error("Invalid array length");
-    }
+export function thresholdsOf(weights) {
+    assert(weights.length > 0, "Invalid array length");
     let previousLimit = 0;
     return weights.map((weight) => (previousLimit += weight));
 }
 export function getRandomElementIndexInWeights(weights) {
-    const thresholds = _getRandomElementIndexInWeight_thresholds(weights);
-    const lotterySecretNumber = Math.random() * thresholds.at(-1);
-    return _getRandomElementIndexInWeight_of_thresholds(thresholds, lotterySecretNumber);
+    const thresholds = thresholdsOf(weights);
+    const lotteryPick = Math.random() * thresholds.at(-1);
+    return pickInThresholds(thresholds, lotteryPick);
 }
 // task: честный алгоритм , для которого каждый из элеметов списка имеет равный шанс на реализацию своей вероятности.
 // Обычно весь список фильтруется и после выбирается элемент. В нашем случае фильтр будет срабатывать только для тех элементов,
@@ -93,10 +108,8 @@ export function getRandomElementIndexInWeights(weights) {
   Повторяем
   */
 export function getRandomElementFromArray(array, { associatedWeights, filter = () => true } = {}) {
-    if (associatedWeights && associatedWeights.length !== array.length) {
-        throw new Error("Incorrectly passed argument associatedWeights: The length of the associatedWeights must exactly match the length of the weights array");
-    }
-    RandomizerContext.from({
+    assert(!associatedWeights || associatedWeights.length === array.length, "Incorrectly passed argument associatedWeights: The length of the associatedWeights must exactly match the length of the weights array");
+    return RandomizerContext.from({
         array,
         associatedWeights,
     }).pickRandom(({ item }) => filter(item));

package/lib/objectives/mod.d.ts

@@ -1,10 +1,12 @@
+export * from "./BusyNumeric.js";
 export * from "./CustomCollector.js";
-export * from "./GlitchText.js";
-export * from "./getRandomNumberInRange.js";
-export * from "./rangeToArray.js";
-export * from "./getRandomElementFromArray.js";
 export * from "./DotNotatedInterface.js";
 export * from "./ExtendedEnum/mod.js";
+export * from "./getRandomElementFromArray.js";
+export * from "./getRandomNumberInRange.js";
+export * from "./GlitchText.js";
+export * from "./LazySort/LazySort.build.js";
+export * from "./rangeToArray.js";
 declare function omit(object: object, filter: CallableFunction): {
     [k: string]: any;
 };

package/lib/objectives/mod.js

@@ -1,10 +1,12 @@
+export * from "./BusyNumeric.js";
 export * from "./CustomCollector.js";
-export * from "./GlitchText.js";
-export * from "./getRandomNumberInRange.js";
-export * from "./rangeToArray.js";
-export * from "./getRandomElementFromArray.js";
 export * from "./DotNotatedInterface.js";
 export * from "./ExtendedEnum/mod.js";
+export * from "./getRandomElementFromArray.js";
+export * from "./getRandomNumberInRange.js";
+export * from "./GlitchText.js";
+export * from "./LazySort/LazySort.build.js";
+export * from "./rangeToArray.js";
 function omit(object, filter) {
     const entries = Object.entries(object).filter(([key, value], i) => filter(key, value, i));
     return Object.fromEntries(entries);

package/lib/primitives/binary_search.d.ts

@@ -1 +1,9 @@
 export declare function binary_search(max: number, compare: (index: number) => number): number;
+export declare const enum BinarySearchResultEnum {
+    NotFound = -1
+}
+export declare const enum BinarySearchCompareSpec {
+    Biggest = 1,
+    Equal = 0,
+    Smallest = -1
+}

package/lib/primitives/binary_search.js

@@ -1,5 +1,8 @@
+import assert from "node:assert";
 // Если большее, то идёт к меньшим
 export function binary_search(max, compare) {
+    assert(max >= 0);
+    assert(Number.isInteger(max));
     let min = 0;
     while (true) {
         const index = Math.floor((min + max) / 2);

package/lib/primitives/mod.d.ts

@@ -1,6 +1,9 @@
-export * from "./TextTableBuilder.js";
+export * from "./binary_search.js";
 export * from "./BracketsParser.js";
 export { CliParser } from "./CliParser.js";
+export * from "./createDefaultPreventable.js";
+export * from "./normalize.js";
+export * from "./TextTableBuilder.js";
 interface IEndingOptions {
     unite?: (quantity: number, word: string) => string;
 }

package/lib/primitives/mod.js

@@ -1,6 +1,9 @@
-export * from "./TextTableBuilder.js";
+export * from "./binary_search.js";
 export * from "./BracketsParser.js";
 export { CliParser } from "./CliParser.js";
+export * from "./createDefaultPreventable.js";
+export * from "./normalize.js";
+export * from "./TextTableBuilder.js";
 function ending(quantity = 0, base, multiple, alone, double, options = {}) {
     if (isNaN(quantity))
         return NaN;

package/lib/primitives/normalize.d.ts

@@ -1 +1 @@
-export declare function normalize_to_integer(list: number[]): number[];
+export declare function normalize_to_max_coefficient(list: number[]): number[];

package/lib/primitives/normalize.js

@@ -1,5 +1,7 @@
-export function normalize_to_integer(list) {
-    // (1 / 3) * 1e15 === 333 333 333 333 333.3
-    const MIN_OPTIMAL_VALUE = 1e16;
-    return list.map((x) => Math.floor(x * MIN_OPTIMAL_VALUE));
+export function normalize_to_max_coefficient(list) {
+    // normalize_to_optimal(2, MAX_SAFE_INTEGER) will be coefficient 1:9007199254740990
+    // normalize_to_optimal(0.25, 3000) will be coefficient 750537393112:9006448717347879
+    const sum = list.reduce((acc, value) => acc + value, 0);
+    const multiplayer = Number.MAX_SAFE_INTEGER / sum;
+    return list.map((x) => Math.floor(x * multiplayer));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zoodogood/utils",
   "type": "module",
-  "version": "4.0.0-change.2617",
+  "version": "4.2.1-change.3358",
   "description": "",
   "main": "lib/index.js",
   "homepage": "https://zoodogood.github.io/utils",
@@ -66,7 +66,7 @@
     }
   },
   "scripts": {
-    "test": "vitest --help",
+    "test": "vitest --run",
     "docs-build": "cd ./docs && retype build  --output ./public",
     "docs-watch": "cd ./docs && retype watch",
     "build": "tsc",