@zoodogood/utils 2.0.2-change.1508 → 3.0.0-change.2568

package/lib/discordjs/helpers.d.ts

@@ -6,7 +6,7 @@ export type APIBaseButton = import("discord-api-types/v10").APIButtonComponentBa
  *
  * @param {Partial<APIBaseButton>[]} resolable
  */
-export function justButtonComponents(...resolable: Partial<import("discord-api-types/v10").APIButtonComponentBase<any>>[]): {
+export function justButtonComponents(...resolable: Partial<APIBaseButton>[]): {
     label?: string | undefined;
     style: any;
     emoji?: import("discord-api-types/v10").APIMessageComponentEmoji | undefined;
@@ -15,4 +15,4 @@ export function justButtonComponents(...resolable: Partial<import("discord-api-t
     customId: string;
 }[];
 export function justSendMessage(target: any, options: any): Promise<any>;
-import { ComponentType as ComponentType_1 } from "discord.js";
+import { ComponentType } from "discord.js";

package/lib/discordjs/helpers.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { BaseInteraction, ButtonStyle, ComponentType } from "discord.js";
 import { CreateMessage } from "./simplify.js";
 const DEFAULTS_FOR_BUTTON = {
@@ -21,34 +12,36 @@ const DEFAULTS_FOR_BUTTON = {
  * @param {Partial<APIBaseButton>[]} resolable
  */
 function justButtonComponents(...resolable) {
-    const buttons = resolable.map((data, i) => (Object.assign(Object.assign(Object.assign({}, DEFAULTS_FOR_BUTTON), { customId: `button.${i + 1}` }), data)));
+    const buttons = resolable.map((data, i) => ({
+        ...DEFAULTS_FOR_BUTTON,
+        customId: `button.${i + 1}`,
+        ...data,
+    }));
     return buttons;
 }
-function justSendMessage(target, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const messagePayload = CreateMessage(options);
-        const message = target instanceof BaseInteraction
-            ? yield (options.edit
-                ? target.replied
-                    ? target.editReply(messagePayload)
-                    : target.update(messagePayload)
-                : target.reply(messagePayload))
-            : yield (options.edit
-                ? target.edit(messagePayload)
-                : target.send(messagePayload));
-        if (options.delete) {
-            setTimeout(() => message.delete(), options.delete);
-        }
-        if (options.reactions) {
-            options.reactions
-                .filter(Boolean)
-                .filter((react) => {
-                var _a;
-                return !((_a = message.reactions) === null || _a === void 0 ? void 0 : _a.cache.some((compared) => compared.emoji.code === react));
-            })
-                .forEach((react) => message.react(react));
-        }
-        return message;
-    });
+async function justSendMessage(target, options) {
+    const messagePayload = CreateMessage(options);
+    const message = target instanceof BaseInteraction
+        ? await (options.edit
+            ? target.replied
+                ? target.editReply(messagePayload)
+                : target.update(messagePayload)
+            : target.reply(messagePayload))
+        : await (options.edit
+            ? target.edit(messagePayload)
+            : target.send(messagePayload));
+    if (options.delete) {
+        setTimeout(() => message.delete(), options.delete);
+    }
+    if (options.reactions) {
+        options.reactions
+            .filter(Boolean)
+            .filter((react) => {
+            var _a;
+            return !((_a = message.reactions) === null || _a === void 0 ? void 0 : _a.cache.some((compared) => compared.emoji.code === react));
+        })
+            .forEach((react) => message.react(react));
+    }
+    return message;
 }
 export { justButtonComponents, justSendMessage };

package/lib/nodejs/getChildProcessUtils.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { ChildProcessWithoutNullStreams } from "child_process";
 import EventsEmitter from "events";
 interface IContext {

package/lib/objectives/BusyNumeric.d.ts

@@ -0,0 +1,29 @@
+/**
+ * MARK: Представьте отель
+ * Часть его номеров свободны, а часть — заняты
+ * Есть две особенности.
+ * 1) При заселении ищется случайный номер
+ * 2) Хотя у нас есть список занятых номеров, у нас не может быть списка свободных (за условием задачи)
+ * Этот алгоритм используется для эффективного поиска тех самых свободных номеров, которые удовлетворяют заданному условию
+ */
+export declare class BusyNumeric {
+    #private;
+    readonly range: number;
+    readonly busy_areas: (readonly [number, number])[];
+    get peak_start_busy(): boolean;
+    get peak_end_busy(): boolean;
+    constructor(range: number);
+    bifurcate(point: number): void;
+    segments_count(): number;
+    segment(at: number): {
+        size: number;
+        left: readonly [number, number];
+        right: readonly [number, number];
+    } | undefined;
+    insert_area(start: number, end: number): void;
+    refresh: {
+        _areas: () => number;
+        _peak: () => void;
+        full: () => void;
+    };
+}

package/lib/objectives/BusyNumeric.js

@@ -0,0 +1,167 @@
+// task: честный алгоритм , для которого каждый из элеметов списка имеет равный шанс на реализацию своей вероятности.
+// Обычно весь список фильтруется и после выбирается элемент. В нашем случае фильтр будет срабатывать только для тех элементов,
+// которые на этапе фильтрации «выбраны» — то есть имеют свою стопроцентную вероятность быть окончательными после успешного прохождения фильтра
+// требования: честная вероятность; итоговая производительность должна быть выше обычной при проходе списка фильтром
+// Алгоритм:
+/*
+  Оптимальный алгоритм поиска случайного элемента списка, удовлетворяющего условию. Поддерживается возможность задавать элементам коэффициент вероятности
+
+  Перед выбором элемента выбираем случайный сегмент, далее случайный элемент в этом сегменте
+
+  Если соответствует условию, возвращаем элемент. Завершаем поиск
+
+  Иначе исключаем элемент путем раздвоения текущего сегмента так, чтобы элемент не оказался ни в одном сегменте списка
+
+  Повторяем
+  */
+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 _BusyNumeric_peak_start_busy, _BusyNumeric_peak_end_busy;
+import { binary_search } from "../primitives/binary_search.js";
+/**
+ * MARK: Представьте отель
+ * Часть его номеров свободны, а часть — заняты
+ * Есть две особенности.
+ * 1) При заселении ищется случайный номер
+ * 2) Хотя у нас есть список занятых номеров, у нас не может быть списка свободных (за условием задачи)
+ * Этот алгоритм используется для эффективного поиска тех самых свободных номеров, которые удовлетворяют заданному условию
+ */
+// Убежден что в алгоритме список busy_areas можно применить структуру бинарных деревьев.
+// Если основное количество производительности не реализуется из-за особенностей структуры списка, то это можно оптимизировать
+// Интересно что ветки дерева можно определять по индексу. Да, это интересное замечание.
+// В BusyNumeric можно добавить ещё метод separate
+export class BusyNumeric {
+    get peak_start_busy() {
+        var _a;
+        if (__classPrivateFieldGet(this, _BusyNumeric_peak_start_busy, "f")) {
+            return true;
+        }
+        if (((_a = this.busy_areas[0]) === null || _a === void 0 ? void 0 : _a[0]) !== 0) {
+            return false;
+        }
+        __classPrivateFieldSet(this, _BusyNumeric_peak_start_busy, true, "f");
+        return true;
+    }
+    get peak_end_busy() {
+        var _a;
+        if (__classPrivateFieldGet(this, _BusyNumeric_peak_end_busy, "f")) {
+            return true;
+        }
+        if (((_a = this.busy_areas.at(-1)) === null || _a === void 0 ? void 0 : _a[1]) !== this.range) {
+            return false;
+        }
+        __classPrivateFieldSet(this, _BusyNumeric_peak_end_busy, true, "f");
+        return true;
+    }
+    constructor(range) {
+        this.busy_areas = [];
+        _BusyNumeric_peak_start_busy.set(this, false);
+        _BusyNumeric_peak_end_busy.set(this, false);
+        this.refresh = {
+            _areas: () => (this.busy_areas.length = 0),
+            _peak: () => {
+                __classPrivateFieldSet(this, _BusyNumeric_peak_start_busy, false, "f");
+                __classPrivateFieldSet(this, _BusyNumeric_peak_end_busy, false, "f");
+            },
+            full: () => {
+                this.refresh._areas();
+                this.refresh._peak();
+            },
+        };
+        if (range <= 0) {
+            throw new Error("Assertion: range must be positive");
+        }
+        this.range = range;
+    }
+    bifurcate(point) {
+        this.insert_area(point, point);
+    }
+    segments_count() {
+        return (this.busy_areas.length + 1 - +this.peak_start_busy - +this.peak_end_busy);
+    }
+    segment(at) {
+        if (!this.range) {
+            return undefined;
+        }
+        const { peak_start_busy, peak_end_busy } = this;
+        const segments_count = this.segments_count();
+        if (at < 0) {
+            if (segments_count + at < 0) {
+                return undefined;
+            }
+            at = segments_count + at;
+        }
+        if (peak_start_busy) {
+            at += 1;
+        }
+        if (peak_end_busy && at > segments_count) {
+            return undefined;
+        }
+        if (at > segments_count + 1) {
+            return undefined;
+        }
+        const left = this.busy_areas[at - 1];
+        const right = this.busy_areas[at];
+        // formula: busy_area_point ± 1 (jump to segment)
+        const start = (left === null || left === void 0 ? void 0 : left[1]) + 1 || 0;
+        const end = right ? right[0] - 1 : this.range;
+        const size = end - start + 1;
+        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?`);
+        }
+        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;
+        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]]);
+            return;
+        }
+        // Merge strategy 2
+        if (is_left_included || is_right_included) {
+            const target = is_left_included ? left : right;
+            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");
+            }
+            this.busy_areas.splice(index, 1, points);
+            return;
+        }
+        // Merge strategy 1
+        this.busy_areas.splice(place_index, 0, [start, end]);
+    }
+}
+_BusyNumeric_peak_start_busy = new WeakMap(), _BusyNumeric_peak_end_busy = new WeakMap();

package/lib/objectives/CustomCollector.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 interface ICustomCollectorOptions {
     target: Required<{
         removeListener: CallableFunction;

package/lib/objectives/getRandomElementFromArray.d.ts

@@ -1,7 +1,27 @@
-interface IParams {
-    needPop?: boolean;
+import { create_default_preventable } from "../primitives/createDefaultPreventable.js";
+import { BusyNumeric } from "./BusyNumeric.js";
+interface IParams<T> {
     associatedWeights?: number[];
+    filter?: (item: T) => boolean;
 }
-export declare function getRandomElementIndexInWeights(weights: NonNullable<IParams["associatedWeights"]>): number | never;
-export declare function getRandomElementFromArray<T>(array: T[], { needPop, associatedWeights }?: IParams): T;
+interface IPickContext<T> {
+    busy_preventable: ReturnType<typeof create_default_preventable>;
+    item: T;
+    pick: (context: IPickContext<T>) => boolean;
+    threshold: number;
+    point: number;
+}
+export declare class RandomizerContext<T> {
+    hotel: BusyNumeric;
+    array: T[];
+    thresholds?: number[];
+    constructor(array: T[], thresholds?: number[]);
+    static from<T>({ array, associatedWeights, }: {
+        array: T[];
+        associatedWeights?: IParams<T>["associatedWeights"];
+    }): RandomizerContext<T>;
+    pickRandom(pick?: IPickContext<T>["pick"]): T | undefined;
+}
+export declare function getRandomElementIndexInWeights(weights: NonNullable<IParams<unknown>["associatedWeights"]>): number | never;
+export declare function getRandomElementFromArray<T>(array: T[], { associatedWeights, filter }?: IParams<T>): void;
 export {};

package/lib/objectives/getRandomElementFromArray.js

@@ -1,24 +1,103 @@
+import { binary_search } from "../primitives/binary_search.js";
+import { create_default_preventable } from "../primitives/createDefaultPreventable.js";
+import { BusyNumeric } from "./BusyNumeric.js";
 import { getRandomNumberInRange } from "./getRandomNumberInRange.js";
-export function getRandomElementIndexInWeights(weights) {
+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;
+        this.hotel = new BusyNumeric(range);
+    }
+    static from({ array, associatedWeights, }) {
+        const thresholds = associatedWeights &&
+            _getRandomElementIndexInWeight_thresholds(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 element = array[index];
+            const pickContext = {
+                busy_preventable: create_default_preventable(),
+                item: element,
+                pick,
+                threshold: index,
+                point,
+            };
+            if (pick(pickContext)) {
+                return element;
+            }
+            if (!pickContext.busy_preventable.default_prevented()) {
+                thresholds
+                    ? hotel.insert_area(thresholds[index - 1] + 1 || 0, thresholds[index])
+                    : hotel.bifurcate(index);
+            }
+        }
+        return undefined;
+    }
+}
+function _getRandomElementIndexInWeight_of_thresholds(thresholds, value) {
+    if (!thresholds.length) {
+        return -1;
+    }
+    return binary_search(thresholds.length - 1, (index) => {
+        var _a;
+        const hold = thresholds[index];
+        if (hold >= value && ((_a = thresholds[index - 1]) !== null && _a !== void 0 ? _a : -1) < value) {
+            return 0;
+        }
+        if (hold < value) {
+            return -1;
+        }
+        return 1;
+    });
+}
+function _getRandomElementIndexInWeight_thresholds(weights) {
     if (weights.length < 1) {
         new Error("Invalid array length");
     }
     let previousLimit = 0;
-    const thresholds = weights.map((weight) => (previousLimit += weight));
+    return weights.map((weight) => (previousLimit += weight));
+}
+export function getRandomElementIndexInWeights(weights) {
+    const thresholds = _getRandomElementIndexInWeight_thresholds(weights);
     const lotterySecretNumber = Math.random() * thresholds.at(-1);
-    return thresholds.findIndex((threshold) => threshold >= lotterySecretNumber);
+    return _getRandomElementIndexInWeight_of_thresholds(thresholds, lotterySecretNumber);
 }
-export function getRandomElementFromArray(array, { needPop, associatedWeights } = {}) {
+// task: честный алгоритм , для которого каждый из элеметов списка имеет равный шанс на реализацию своей вероятности.
+// Обычно весь список фильтруется и после выбирается элемент. В нашем случае фильтр будет срабатывать только для тех элементов,
+// которые на этапе фильтрации «выбраны» — то есть имеют свою стопроцентную вероятность быть окончательными после успешного прохождения фильтра
+// требования: честная вероятность; итоговая производительность должна быть выше обычной при проходе списка фильтром
+// Алгоритм:
+/*
+  Оптимальный алгоритм поиска случайного элемента списка, удовлетворяющего условию. Поддерживается возможность задавать элементам коэффициент вероятности
+
+  Перед выбором элемента выбираем случайный сегмент, далее случайный элемент в этом сегменте
+
+  Если соответствует условию, возвращаем элемент. Завершаем поиск
+
+  Иначе исключаем элемент путем раздвоения текущего сегмента так, чтобы элемент не оказался ни в одном сегменте списка
+
+  Повторяем
+  */
+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");
     }
-    const index = associatedWeights
-        ? getRandomElementIndexInWeights(associatedWeights)
-        : getRandomNumberInRange({ max: array.length - 1 });
-    const input = array[index];
-    if (needPop) {
-        array.splice(index, 1);
-        associatedWeights === null || associatedWeights === void 0 ? void 0 : associatedWeights.splice(index, 1);
-    }
-    return input;
+    RandomizerContext.from({
+        array,
+        associatedWeights,
+    }).pickRandom(({ item }) => filter(item));
 }

package/lib/primitives/BracketsParser.js

@@ -97,7 +97,7 @@ export class BracketsParser {
             return;
         }
         const start = context.stack.pop();
-        const end = StackElement.from(Object.assign(Object.assign({}, match), { key: variant.key, variant }));
+        const end = StackElement.from({ ...match, key: variant.key, variant });
         const group = this._createGroup(start, end, context);
         context.appendGroup(group);
         return end;
@@ -127,7 +127,7 @@ export class BracketsParser {
             return null;
         }
         const { match, variant } = result;
-        const start = StackElement.from(Object.assign(Object.assign({}, match), { key: variant.key, variant }));
+        const start = StackElement.from({ ...match, key: variant.key, variant });
         context.stack.push(start);
         return start;
     }

package/lib/primitives/TextTableBuilder.js

@@ -227,7 +227,7 @@ var SpecialRowTypeEnum;
 class TextTableBuilder {
     constructor() {
         this.rows = [];
-        this.options = Object.assign({}, DEFAULT_TABLE_OPTIONS);
+        this.options = { ...DEFAULT_TABLE_OPTIONS };
     }
     setBorderOptions(callback = () => "|", directions = [
         BorderDirectionEnum.BorderLeft,

package/lib/primitives/binary_search.d.ts

@@ -0,0 +1 @@
+export declare function binary_search(max: number, compare: (index: number) => number): number;

package/lib/primitives/binary_search.js

@@ -0,0 +1,19 @@
+// Если большее, то идёт к меньшим
+export function binary_search(max, compare) {
+    let min = 0;
+    while (true) {
+        const index = Math.floor((min + max) / 2);
+        const compared = compare(index);
+        if (compared === 0) {
+            return index;
+        }
+        if (min === max) {
+            return -1;
+        }
+        if (compared > 0) {
+            max = index - 1;
+            continue;
+        }
+        min = index + 1;
+    }
+}

package/lib/primitives/createDefaultPreventable.d.ts

@@ -0,0 +1,4 @@
+export declare function create_default_preventable(): {
+    default_prevented: () => boolean;
+    prevent_default: () => void;
+};

package/lib/primitives/createDefaultPreventable.js

@@ -0,0 +1,8 @@
+export function create_default_preventable() {
+    let is_prevented = false;
+    const default_prevented = () => is_prevented;
+    const prevent_default = () => {
+        is_prevented = true;
+    };
+    return { default_prevented, prevent_default };
+}

package/lib/primitives/normalize.d.ts

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

package/lib/primitives/normalize.js

@@ -0,0 +1,5 @@
+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));
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@zoodogood/utils",
   "type": "module",
-  "version": "2.0.2-change.1508",
+  "version": "3.0.0-change.2568",
   "description": "",
   "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "homepage": "https://zoodogood.github.io/utils",
+  "types": "lib/index.d.ts",
   "typings": "lib/index",
   "exports": {
     ".": "./lib/index.js",
@@ -23,19 +23,19 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "@types/node": "^20.5.9",
-    "@typescript-eslint/eslint-plugin": "^6.13.1",
-    "@typescript-eslint/parser": "^6.13.1",
-    "@vitest/ui": "^1.2.1",
-    "discord-api-types": "^0.37.65",
-    "discord.js": "^14.13.0",
-    "eslint": "^8.54.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-prettier": "^5.0.1",
-    "prettier": "^3.1.0",
-    "retypeapp-linux-x64": "^3.3.0",
-    "typescript": "^5.2.2",
-    "vitest": "^0.34.5"
+    "@types/node": "^22.5.4",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "@vitest/ui": "^2.0.5",
+    "discord-api-types": "^0.37.99",
+    "discord.js": "^14.16.1",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "prettier": "^3.3.3",
+    "retypeapp-linux-x64": "^3.5.0",
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5"
   },
   "peerDependencies": {
     "discord.js": ">=14.x.x"
@@ -66,7 +66,7 @@
     }
   },
   "scripts": {
-    "test": "vitest run",
+    "test": "vitest --help",
     "docs-build": "cd ./docs && retype build  --output ./public",
     "docs-watch": "cd ./docs && retype watch",
     "build": "tsc",