@nemigo/helpers 0.13.2 → 1.5.0

package/dist/mutate.js

@@ -0,0 +1,130 @@
+import { isObject, isSameType } from "./index.js";
+/**
+ * Рекурсивно модифицирует объект, приводя его структуру к виду целевого объекта.
+ * Использует внутри {@link deepMutateArray}
+ *
+ * Удаляет лишние свойства, обновляет существующие и добавляет новые.
+ * Работает **мутативно** — изменяет исходный объект напрямую
+ *
+ * @remarks **НЕ** предназначен для работы с декларативными методами (могут потерять `this`)
+ *
+ * @example
+ * ```typescript
+ * const source = { a: 1, b: 2, c: 3 };
+ * const target = { a: 10, d: 40 };
+ *
+ * deepMutateObject(source, target);
+ * // source теперь: { a: 10, d: 40 }
+ * // свойства b и c удалены, a обновлено, d добавлено
+ * ```
+ */
+export const deepMutateObject = (source, target) => {
+    // Удаление лишних свойств
+    Object.keys(source).forEach((key) => {
+        if (!(key in target))
+            delete source[key];
+    });
+    // Обновление свойств
+    Object.entries(target).forEach(([key, targetValue]) => {
+        const sourceValue = source[key];
+        // Проверка изменения типа данных
+        if (!isSameType(sourceValue, targetValue)) {
+            source[key] = targetValue; // Полная замена при разном типе
+            return;
+        }
+        if (Array.isArray(targetValue)) {
+            if (!Array.isArray(sourceValue))
+                source[key] = [];
+            deepMutateArray(source[key], targetValue);
+        }
+        else if (isObject(targetValue)) {
+            if (!isObject(sourceValue))
+                source[key] = {};
+            deepMutateObject(source[key], targetValue);
+        }
+        else if (sourceValue !== targetValue) {
+            source[key] = targetValue;
+        }
+    });
+};
+/**
+ * Рекурсивно модифицирует массив, приводя его к виду целевого массива.
+ * Использует внутри {@link deepMutateObject}
+ *
+ * Обрезает лишние элементы, обновляет существующие и добавляет новые.
+ * Работает **мутативно** — изменяет исходный массив напрямую
+ *
+ * @example
+ * ```typescript
+ * const complexSource = [
+ *   { id: 1, name: "John" },
+ *   { id: 2, name: "Jane" }
+ * ];
+ * const complexTarget = [
+ *   { id: 1, name: "Johnny" },
+ *   { id: 3, name: "Bob" }
+ * ];
+ *
+ * deepMutateArray(complexSource, complexTarget);
+ *
+ * // complexSource теперь: [
+ * //   { id: 1, name: "Johnny" },
+ * //   { id: 3, name: "Bob" }
+ * // ]
+ * ```
+ */
+export const deepMutateArray = (source, target) => {
+    // Обрезка длины массива
+    if (source.length > target.length) {
+        source.splice(target.length, source.length - target.length);
+    }
+    // Обновление элементов
+    target.forEach((targetItem, index) => {
+        const sourceItem = source[index];
+        if (Array.isArray(targetItem)) {
+            if (!Array.isArray(sourceItem))
+                source[index] = [];
+            deepMutateArray(source[index], targetItem);
+        }
+        else if (isObject(targetItem)) {
+            if (!isObject(sourceItem))
+                source[index] = {};
+            deepMutateObject(source[index], targetItem);
+        }
+        else if (sourceItem !== targetItem) {
+            source[index] = targetItem;
+        }
+    });
+    // Добавление новых элементов
+    while (source.length < target.length) {
+        source.push(target[source.length]);
+    }
+};
+/**
+ * Заменяет метод объекта обёрткой, передающей управление указанной функции
+ *
+ * Обёртка предоставляет контекст с оригинальным объектом, прокси-методом через {@link Reflect.apply} для вызова
+ * исходной реализации и аргументами вызова
+ *
+ * @param self - Объект, метод которого будет заменён
+ * @param key - Ключ метода в объекте
+ * @param func - Функция-обработчик, получающая контекст вызова
+ * @param [dynamic=false] - Использовать связывание `this` при вызове, что позволяет переносить цепочки на другие объекты
+ *
+ * @throws {TypeError} Если `self[key]` не является функцией
+ */
+export const inject = (self, key, func, dynamic = false) => {
+    const original = self[key];
+    if (dynamic) {
+        // динамический this
+        self[key] = function (...args) {
+            const method = (...args) => Reflect.apply(original, this, args);
+            return func({ self: this, method, args });
+        };
+    }
+    else {
+        // статический (захват self и original на момент вызова)
+        const method = (...args) => Reflect.apply(original, self, args);
+        self[key] = ((...args) => func({ self, method, args }));
+    }
+};

package/dist/omitter.d.ts

@@ -1,72 +1,88 @@
 import type { DeepPartial, KEYS } from "./types.js";
 import type { ZIP } from "./zipper.js";
 /**
- * Исключает ключи из объекта `Source`, которые присутствуют в объекте `Target`.
- * Если значение ключа в `Source` и `Target` является объектом, рекурсивно применяет `OmitKEYS` к этим объектам
+ * Исключает ключи из объекта `Source`, которые присутствуют в объекте `Target`
+ *
+ * Если значение ключа в `Source` и `Target` является объектом, рекурсивно применяет себя к этим объектам
+ *
+ * @remarks Криво работает с функциональными методами и **НЕ** имеет защиты от бесконечных рекурсий
  *
  * @template Source - Исходный объект, из которого нужно исключить ключи
  * @template Target - Объект, ключи которого нужно исключить из `Source`
  *
  * @example
- * type Source = { a: number; b: { c: string; d: boolean }; e: string };
- * type Target = { b: { c: string }; e: string };
- * type Result = ExtractOmitSchema<Source, Target>; // { a: number; b: { d: boolean } }
+ * ```typescript
+ * type Source = { a: number; b: { c: string; d: boolean }; e: string }
+ * type Target = { b: { c: string }; e: string }
+ * type Result = ExtractOmitSchema<Source, Target> // { a: number; b: { d: boolean } }
+ * ```
  */
 export type ExtractOmitSchema<Source, Target extends DeepPartial<Source>> = {
     [K in keyof Source as K extends keyof Target ? Source[K] extends Record<string, unknown> ? Target[K] extends Record<string, unknown> ? K : never : never : K]: K extends keyof Target ? Source[K] extends Record<string, unknown> ? Target[K] extends Record<string, unknown> & DeepPartial<Source[K]> ? ExtractOmitSchema<Source[K], Target[K]> : never : never : null;
 };
 /**
- * Вычисляет тип Target на основе исходного типа Source и схемы удаления OmitSchema.
+ * Вычисляет тип Target на основе исходного типа Source и схемы удаления OmitSchema
+ *
  * Удаляет ключи, помеченные в схеме как null, и рекурсивно обрабатывает вложенные объекты
  *
+ * @remarks Криво работает с функциональными методами и **НЕ** имеет защиты от бесконечных рекурсий
+ *
+ * @template Source - Исходный тип объекта
+ * @template OmitSchema - Схема удаления ключей
+ *
  * @example
- * type Source = { a: number; b: { c: string; d: boolean }; e: string };
- * type OmitSchema = { a: null; b: { c: null } };
- * type Result = ExtractOmitTarget<Source, OmitSchema>; // { b: { d: boolean }; e: string }
+ * ```typescript
+ * type Source = { a: number; b: { c: string; d: boolean }; e: string }
+ * type OmitSchema = { a: null; b: { c: null } }
+ * type Result = ExtractOmitTarget<Source, OmitSchema> // { b: { d: boolean }; e: string }
+ * ```
  */
 export type ExtractOmitTarget<Source, OmitSchema> = {
     [K in keyof Source as K extends keyof OmitSchema ? (OmitSchema[K] extends Record<string, unknown> ? K : never) : K]: K extends keyof OmitSchema ? OmitSchema[K] extends Record<string, unknown> ? ExtractOmitTarget<Source[K], OmitSchema[K]> : never : Source[K];
 };
 /**
- * Рекурсивно объединяет две схемы удаления ключей.
+ * Рекурсивно объединяет две схемы удаления ключей
+ *
  * Если ключ присутствует в обеих схемах:
  * - Если оба значения являются объектами — объединяет вложенные схемы
  * - Если хотя бы одно значение null — результат null (приоритет удаления)
  *
  * @example
+ * ```typescript
+ * type SchemaA = { a: null; b: { c: null } }
+ * type SchemaB = { b: { d: null }; e: null }
+ * type MergedSchema = MergeOmitSchemas<SchemaA, SchemaB> // { a: null; b: { c: null; d: null }; e: null }
  *
- * type SchemaA = { a: null; b: { c: null } };
- * type SchemaB = { b: { d: null }; e: null };
- *
- * type MergedSchema = MergeOmitSchemas<SchemaA, SchemaB>;
- * // Результат: { a: null; b: { c: null; d: null }; e: null }
- *
- * type ConflictSchema = MergeOmitSchemas<
- *   { user: { name: null } },
- *   { user: null }
- * >;
- * // Результат: { user: null } (приоритет удаления)
+ * type ConflictSchema = MergeOmitSchemas<{ user: { name: null } }, { user: null }> // { user: null }
+ * ```
  */
 export type MergeOmitSchemas<S1, S2> = {
     [K in keyof (S1 & S2)]: K extends keyof S1 ? K extends keyof S2 ? S1[K] extends Record<string, unknown> ? S2[K] extends Record<string, unknown> ? MergeOmitSchemas<S1[K], S2[K]> : null : null : S1[K] : K extends keyof S2 ? S2[K] : never;
 };
 /**
- * Класс для удаления указанных ключей из объекта на основе схемы
+ * Очистка объектов от свойств на основе схемы
  *
- * @template Source - Исходный объект, из которого нужно удалить ключи
+ * @remarks Мутирует исходный объект
+ *
+ * @template Source - Тип объектов, из которых нужно удалить ключи
  * @template OmitSchema - Схема удаления
  *
  * @example
- * const source = { a: 1, b: { c: 2, d: 3 }, e: 4 };
- * const schema = { b: { c: null } };
- * const omitter = new Omitter(schema);
- * const result = omitter.run(source); // { a: 1, b: { d: 3 }, e: 4 }
+ * ```typescript
+ * const source = { a: 1, b: { c: 2, d: 3 }, e: 4 }
+ * const schema = { b: { c: null } }
+ * const omitter = new Omitter(schema)
+ * const result = omitter.apply(source) // { a: 1, b: { d: 3 }, e: 4 }
+ * ```
  */
 export declare class Omitter<Source, OmitSchema> {
     #private;
-    private readonly structure;
-    readonly schema: OmitSchema;
-    readonly zip: ZIP;
+    __structure: {
+        keys: Set<KEYS<OmitSchema>>;
+        nested: Map<KEYS<OmitSchema>, Omitter<any, any>>;
+    };
+    schema: OmitSchema;
+    zip: ZIP;
     constructor(schema: OmitSchema);
     /**
      * Получение хэша вложенного эмиттера
@@ -77,10 +93,17 @@ export declare class Omitter<Source, OmitSchema> {
      */
     left(key: KEYS<Source>): boolean;
     /**
-     * Удаление ключей из объекта
+     * Удаление ключей из объекта по внутренней структуры
+     *
+     * @remarks Мутирует исходный объект
      *
-     * @param source - Исходный объект
-     * @returns Объект с удалёнными ключами
+     * @example
+     * ```typescript
+     * const source = { a: 1, b: { c: 2, d: 3 }, e: 4 }
+     * const schema = { b: { c: null } }
+     * const omitter = new Omitter(schema)
+     * const result = omitter.apply(source) // { a: 1, b: { d: 3 }, e: 4 }
+     * ```
      */
-    run(source: Source): ExtractOmitTarget<Source, OmitSchema>;
+    apply(source: Source): ExtractOmitTarget<Source, OmitSchema>;
 }

package/dist/omitter.js

@@ -1,18 +1,22 @@
 import { zipper } from "./zipper.js";
 /**
- * Класс для удаления указанных ключей из объекта на основе схемы
+ * Очистка объектов от свойств на основе схемы
  *
- * @template Source - Исходный объект, из которого нужно удалить ключи
+ * @remarks Мутирует исходный объект
+ *
+ * @template Source - Тип объектов, из которых нужно удалить ключи
  * @template OmitSchema - Схема удаления
  *
  * @example
- * const source = { a: 1, b: { c: 2, d: 3 }, e: 4 };
- * const schema = { b: { c: null } };
- * const omitter = new Omitter(schema);
- * const result = omitter.run(source); // { a: 1, b: { d: 3 }, e: 4 }
+ * ```typescript
+ * const source = { a: 1, b: { c: 2, d: 3 }, e: 4 }
+ * const schema = { b: { c: null } }
+ * const omitter = new Omitter(schema)
+ * const result = omitter.apply(source) // { a: 1, b: { d: 3 }, e: 4 }
+ * ```
  */
 export class Omitter {
-    structure;
+    __structure;
     schema;
     zip;
     constructor(schema) {
@@ -27,25 +31,10 @@ export class Omitter {
             }
             return true;
         }));
-        this.structure = { keys, nested };
-    }
-    /**
-     * Получение хэша вложенного эмиттера
-     */
-    into(key) {
-        return this.structure.nested.get(key)?.zip;
-    }
-    /**
-     * Проверяет, останется ли ключ в итоговом объекте
-     */
-    left(key) {
-        return !this.structure.keys.has(key);
+        this.__structure = { keys, nested };
     }
     /**
      * Рекурсивно удаляет ключи из объекта на основе структуры
-     *
-     * @param obj - Объект, из которого нужно удалить ключи
-     * @param structure - Структура, определяющая ключи для удаления
      */
     #process(obj, structure) {
         const schema = structure.keys.size + structure.nested.size;
@@ -58,7 +47,7 @@ export class Omitter {
             structure.nested.forEach((omitter, key) => {
                 const nested = obj[key];
                 if (nested && typeof nested === "object")
-                    omitter.#process(nested, omitter.structure);
+                    omitter.#process(nested, omitter.__structure);
             });
         }
         else {
@@ -72,7 +61,7 @@ export class Omitter {
                     if (omitter) {
                         const nested = obj[key];
                         if (nested && typeof nested === "object") {
-                            omitter.#process(nested, omitter.structure);
+                            omitter.#process(nested, omitter.__structure);
                         }
                     }
                 }
@@ -80,13 +69,32 @@ export class Omitter {
         }
     }
     /**
-     * Удаление ключей из объекта
+     * Получение хэша вложенного эмиттера
+     */
+    into(key) {
+        return this.__structure.nested.get(key)?.zip;
+    }
+    /**
+     * Проверяет, останется ли ключ в итоговом объекте
+     */
+    left(key) {
+        return !this.__structure.keys.has(key);
+    }
+    /**
+     * Удаление ключей из объекта по внутренней структуры
+     *
+     * @remarks Мутирует исходный объект
      *
-     * @param source - Исходный объект
-     * @returns Объект с удалёнными ключами
+     * @example
+     * ```typescript
+     * const source = { a: 1, b: { c: 2, d: 3 }, e: 4 }
+     * const schema = { b: { c: null } }
+     * const omitter = new Omitter(schema)
+     * const result = omitter.apply(source) // { a: 1, b: { d: 3 }, e: 4 }
+     * ```
      */
-    run(source) {
-        this.#process(source, this.structure);
+    apply(source) {
+        this.#process(source, this.__structure);
         return source;
     }
 }

package/dist/path.d.ts

@@ -1,3 +1,22 @@
-export declare const pathRegExp: RegExp;
+/**
+ * Преобразует путь в Unix-формат, заменяя все разделители на прямые слэши
+ *
+ * @example
+ * ```typescript
+ * toUnixPath("C:\\Users\\Project"); // "C:/Users/Project"
+ * toUnixPath("src\\components\\file.ts"); // "src/components/file.ts"
+ * ```
+ */
 export declare const toUnixPath: (path: string) => string;
+/**
+ * Проверяет, является ли один путь дочерним {@link String.startsWith} по отношению к другому.
+ * Использует {@link toUnixPath} для нормализации путей
+ *
+ * @example
+ * ```typescript
+ * isChildPath("/home/user", "\\home\\user\\project"); // true
+ * isChildPath("src", "src/components/file.ts"); // true
+ * isChildPath("/home/user", "/home/other"); // false
+ * ```
+ */
 export declare const isChildPath: (parentPath: string, childPath: string) => boolean;

package/dist/path.js

@@ -1,5 +1,24 @@
-export const pathRegExp = /[\\/]/g;
-export const toUnixPath = (path) => path.replace(pathRegExp, "/");
+/**
+ * Преобразует путь в Unix-формат, заменяя все разделители на прямые слэши
+ *
+ * @example
+ * ```typescript
+ * toUnixPath("C:\\Users\\Project"); // "C:/Users/Project"
+ * toUnixPath("src\\components\\file.ts"); // "src/components/file.ts"
+ * ```
+ */
+export const toUnixPath = (path) => path.replaceAll("\\", "/");
+/**
+ * Проверяет, является ли один путь дочерним {@link String.startsWith} по отношению к другому.
+ * Использует {@link toUnixPath} для нормализации путей
+ *
+ * @example
+ * ```typescript
+ * isChildPath("/home/user", "\\home\\user\\project"); // true
+ * isChildPath("src", "src/components/file.ts"); // true
+ * isChildPath("/home/user", "/home/other"); // false
+ * ```
+ */
 export const isChildPath = (parentPath, childPath) => {
     const uChildPath = toUnixPath(childPath);
     const nParentPath = toUnixPath(parentPath) + "/";

package/dist/phymath/format.d.ts

@@ -0,0 +1,60 @@
+import type { CanBeNullable } from "../types.js";
+/**
+ * Стратегии обработки нуля в {@link toNumberFormat}:
+ * - "always" - "0" для всех исключительных ситуаций
+ * - "value" - "0" только при значении равном нулю, иначе `fallback`
+ * - "never" - `fallback` всегда
+ */
+export type NumberFormatZeroStrategy = "always" | "value" | "never";
+/**
+ * Конфигурация вывода из {@link toNumberFormat}
+ */
+export interface NumberFormatConfig {
+    /**
+     * Количество знаков после запятой
+     */
+    fraction?: number;
+    /**
+     * Значение для исключительных ситуаций
+     *
+     * @see {@link NumberFormatZeroStrategy}
+     */
+    fallback?: string;
+    /**
+     * @example "₽"
+     */
+    postfix?: string;
+    /**
+     * Стратегия обработки нуля
+     */
+    zero?: NumberFormatZeroStrategy;
+    /**
+     * Разделитель дробной части
+     */
+    fractional?: string;
+    /**
+     * Разделитель тысяч
+     */
+    separator?: string;
+}
+export declare const NumberFormatRegExp: RegExp;
+/**
+ * Форматирование числа по тысячам
+ *
+ * @param value - Входное значение (число, строка, null, undefined)
+ * @param [config] - Конфигурация форматирования
+ * @param [config.fraction=2] - {@link NumberFormatConfig.fraction}
+ * @param [config.fallback="---"] - {@link NumberFormatConfig.fallback}
+ * @param [config.postfix=""] - {@link NumberFormatConfig.postfix}
+ * @param [config.zero="value"] - {@link NumberFormatConfig.zero}
+ * @param [config.fractional=","] - {@link NumberFormatConfig.fractional}
+ * @param [config.separator=" "] - {@link NumberFormatConfig.separator}
+ *
+ * @example
+ * ```typescript
+ * toNumberFormat(1234); // "1 234"
+ * toNumberFormat(1234.5); // "1 234,50"
+ * toNumberFormat(1234.56); // "1 234,56"
+ * ```
+ */
+export declare const toNumberFormat: (value: CanBeNullable<number | string>, { fraction, fallback, zero, postfix, fractional, separator }?: NumberFormatConfig) => string;

package/dist/phymath/format.js

@@ -0,0 +1,34 @@
+import { caseNumber } from "../cases.js";
+import { round } from "./index.js";
+export const NumberFormatRegExp = /\B(?=(\d{3})+(?!\d))/g;
+/**
+ * Форматирование числа по тысячам
+ *
+ * @param value - Входное значение (число, строка, null, undefined)
+ * @param [config] - Конфигурация форматирования
+ * @param [config.fraction=2] - {@link NumberFormatConfig.fraction}
+ * @param [config.fallback="---"] - {@link NumberFormatConfig.fallback}
+ * @param [config.postfix=""] - {@link NumberFormatConfig.postfix}
+ * @param [config.zero="value"] - {@link NumberFormatConfig.zero}
+ * @param [config.fractional=","] - {@link NumberFormatConfig.fractional}
+ * @param [config.separator=" "] - {@link NumberFormatConfig.separator}
+ *
+ * @example
+ * ```typescript
+ * toNumberFormat(1234); // "1 234"
+ * toNumberFormat(1234.5); // "1 234,50"
+ * toNumberFormat(1234.56); // "1 234,56"
+ * ```
+ */
+export const toNumberFormat = (value, { fraction = 2, fallback = "---", zero = "value", postfix, fractional = ",", separator = " " } = {}) => caseNumber(value, (v) => {
+    if (v === undefined)
+        return zero === "always" ? (postfix ? "0 " + postfix : "0") : fallback;
+    if (v === 0)
+        return zero === "never" ? fallback : postfix ? "0 " + postfix : "0";
+    if (fraction === 0)
+        return Math.round(v).toString().replace(NumberFormatRegExp, separator);
+    const { 0: integer, 1: float = "" } = round(v, fraction).toString().split(".");
+    const result = integer.replace(NumberFormatRegExp, separator);
+    const formatted = float ? `${result}${fractional}${float}` : result;
+    return postfix ? formatted + " " + postfix : formatted;
+});

package/dist/phymath/index.d.ts

@@ -1,56 +1,56 @@
 /**
- * Приведение -/+ 0 к 0
+ * Приведение -0 и +0 к обычному 0
+ *
+ * Если не 0, то вернётся исходное значение
  */
-export declare const toZero: (value: number) => number;
+export declare const normalizero: (value: number) => number;
+export type RoundMethod = "up" | "down" | "math";
 /**
  * Округляет число до заданного количества знаков после запятой
  *
- * Если переданное значение является `NaN` возвращает 0
+ * Если переданное значение является `NaN` или 0, возвращает 0
  *
- * @param {number} value - Число для округления
- * @param {number} [fraction=2] - Количество знаков после запятой
- * @returns {number} Округленное число
+ * @param value - Число для округления
+ * @param [fraction=2] - Количество знаков после запятой
+ * @param [method="math"] - Метод округления
  */
-export declare const toRound: (value: number, fraction?: number) => number;
+export declare const round: (value: number, fraction?: number, method?: RoundMethod) => number;
 /**
  * Вычисляет сумму всех переданных аргументов
  *
- * Сумма округляется с использованием функции {@link toRound}
- *
- * @param {...number} args - Числа для суммирования
- * @returns {number} Округленная сумма переданных чисел (или 0)
+ * Для пустого массива возвращает 0
  */
 export declare const sum: (...args: number[]) => number;
 /**
  * Вычисляет произведение всех переданных аргументов
  *
- * Произведение округляется с использованием функции {@link toRound}
- *
- * @param {...number} args - Числа для перемножения.
- * @returns {number} Округленное произведение переданных чисел (или 1)
+ * Для пустого массива возвращает 1
  */
 export declare const mult: (...args: number[]) => number;
 /**
  * Ограничивает значение в заданном диапазоне [min, max]
  *
- * Если значение меньше min, вернёт min. Если больше max — вернёт max.
- * Иначе возвращает само значение без изменений.
- *
- * @param {number} v - Исходное значение для ограничения
- * @param {number} min - Нижняя граница диапазона
- * @param {number} max - Верхняя граница диапазона
- *
- * @returns {number} Значение, ограниченное диапазоном [min, max]
+ * @example
+ * ```typescript
+ * clamp(5, 0, 10); // 5
+ * clamp(-5, 0, 10); // 0
+ * clamp(15, 0, 10); // 10
+ * ```
  */
-export declare const clamp: (v: number, min: number, max: number) => number;
-export declare const toRadians: (deg: number) => number;
+export declare const clamp: (value: number, min: number, max: number) => number;
+/**
+ * Преобразует градусы в радианы
+ */
+export declare const toRadians: (degrees: number) => number;
+/**
+ * Преобразует радианы в градусы
+ */
+export declare const toDegrees: (radians: number) => number;
 /**
  * Линейная интерполяция между двумя числами
  *
- * @param {number} a - Начальное значение
- * @param {number} b - Конечное значение
- * @param {number} t - Весовой коэффициент, определяющий пропорцию между начальным и конечным значениями. Значение должно быть в диапазоне [0, 1]
- *
- * @returns {number} Результат линейной интерполяции между a и b при коэффициенте t
+ * @param a - Начальное значение
+ * @param b - Конечное значение
+ * @param t - Весовой коэффициент, определяющий состояние пропорции между начальным и конечным значениями. Должно быть в диапазоне `[0, 1]`
  */
 export declare const lerp: (a: number, b: number, t: number) => number;