@3dsource/utils 1.0.19 → 1.0.21

package/index.d.ts

@@ -1,5 +1,865 @@
+import * as rxjs from 'rxjs';
+import { Observable, SchedulerLike } from 'rxjs';
+
 /**
- * Generated bundle index. Do not edit.
+ * RGB from each of the CMYK values to determine a return as an any[].
+ * CMYK values are as follows.
+ * C - a number between 0 and 255 representing cyan
+ * M - number between 0 and 255 representing magenta
+ * Y - number between 0 and 255 representing yellow
+ * K - number between 0 and 255 representing black
+ *
+ **/
+declare function CMYKtoRGB(c: number, m: number, y: number, k: number): any[];
+
+declare function HEXtoRGB(color: number | string): {
+    r: number;
+    g: number;
+    b: number;
+};
+
+declare function hsv(h: number, s: number, v: number): number;
+
+/**
+ * HSV from each of the RGB values to determine a return as an any[].
+ * RGB values are as follows.
+ * R - a number from 0 to 255
+ * G - a number from 0 to 255
+ * B - a number from 0 to 255
+ *
+ * HSV values are as follows.
+ * H - a number between 360-0
+ * S - number between 0 and 1.0
+ * V - number between 0 and 1.0
+ *
+ * H is replaced with equivalent numbers in the range of the 360-0 that is out of range.
+ * Cannot compute, including alpha.
+ *
+ * @ Param h hue (Hue) number that indicates (to 360-0)
+ * @ Param s the saturation (Saturation) shows the number (0.0 to 1.0)
+ * @ Param v lightness (Value) indicates the number (0.0 to 1.0)
+ * @ Return RGB values into an any[] of [R, G, B]
+ **/
+declare function HSVtoRGB(h: number, s: number, v: number): number[];
+
+declare function max(col1: number, col2: number): number;
+
+declare function min(col1: number, col2: number): number;
+
+declare function overlay(col1: number, col2: number): number;
+
+/**
+ *  Values calculated from each RGB * RGB color value.
+ * @ Param r the red (R) indicating the number (0-255)
+ * @ Param g green (G) indicates the number (0-255)
+ * @ Param b blue (B) shows the number (0-255)
+ * @ Return obtained from the RGB color value for each indicating the number
+ **/
+declare function rgb(r: number, g: number, b: number): number;
+
+/**
+ * RGB from the respective figures, HSV sequences in terms of returns.
+ * RGB values are as follows.
+ * R - a number from 0 to 255
+ * G - a number from 0 to 255
+ * B - a number from 0 to 255
+ *
+ * CMYK values are as follows.
+ * C - a number between 0 and 255 representing cyan
+ * M - number between 0 and 255 representing magenta
+ * Y - number between 0 and 255 representing yellow
+ * K - number between 0 and 255 representing black
+ *
+ * Cannot compute, including alpha.
+ * @ Param r the red (R) indicating the number (0x00 to 0xFF to)
+ * @ Param g green (G) indicates the number (0x00 to 0xFF to)
+ * @ Param b blue (B) shows the number (0x00 to 0xFF to)
+ * @ Return CMYK values into an any[] of [H, S, V]
+ **/
+declare function RGBtoCMYK(r: number, g: number, b: number): any[];
+
+declare function RGBtoHEX(r: number, g: number, b: number): string;
+
+/**
+ * RGB from the respective figures, HSV sequences in terms of returns.
+ * RGB values are as follows.
+ * R - a number from 0 to 255
+ * G - a number from 0 to 255
+ * B - a number from 0 to 255
+ *
+ * HSV values are as follows.
+ * H - a number between 360-0
+ * S - number between 0 and 1.0
+ * V - number between 0 and 1.0
+ *
+ * Cannot compute, including alpha.
+ * @ Param r the red (R) indicating the number (0x00 to 0xFF to)
+ * @ Param g green (G) indicates the number (0x00 to 0xFF to)
+ * @ Param b blue (B) shows the number (0x00 to 0xFF to)
+ * @ Return HSV values into an any[] of [H, S, V]
+ **/
+declare function RGBtoHSV(r: number, g: number, b: number): number[];
+
+declare function sub(col1: number, col2: number): number;
+
+declare function subtract(col1: number, col2: number): number;
+
+declare function sum(col1: number, col2: number): number;
+
+/**
+ * RGB figures show (0x000000 0xFFFFFF up from) the
+ * R, G, B returns an any[] divided into a number from 0 to 255, respectively.
+ *
+ * @ Param rgb numbers show (0x000000 0xFFFFFF up from)
+ * @ Return any[] indicates the value of each color [R, G, B]
+ **/
+declare function toRGB(rgb: number): number[];
+
+declare function toRGBA(rgba: number): number[];
+
+declare const COLOR_CODES: {
+    readonly TO_UNREAL: readonly ["#ffffff", "#005912", "UNREAL <-"];
+    readonly TAP_LOG: readonly ["#ffff00", "#1976d2", " [TAPLOG]"];
+    readonly FROM_UNREAL: readonly ["#ffff00", "#898989", "UNREAL ->"];
+    readonly FROM_UNREAL_ERROR: readonly ["#ffffff", "#ff0000", "UNREAL ERROR ->"];
+    readonly FROM_CIRRUS: readonly ["#ffffff", "#ef702b", "CIRRUS ->"];
+    readonly FROM_CIRRUS_ERROR: readonly ["#ffffff", "#ff0000", "CIRRUS ->"];
+    readonly TO_CIRRUS: readonly ["#ffffff", "#3c9738", "CIRRUS <-"];
+};
+
+declare const DOCUMENT_ROOT: any;
+
+declare function CSV2Array(strData: any, strDelimiter?: string): any[];
+
+declare function CSV2Records(csv: string, useRowAsHead?: number, strDelimiter?: string): any;
+
+declare function ObjectToCSV<T extends object>(records: T[]): string | undefined;
+
+declare const isLocalhost: boolean;
+
+declare class Logger {
+    static isDevMode: boolean;
+    static colored(color: string, background: string, ...args: unknown[]): void;
+    static log(...args: unknown[]): void;
+    static warn(...args: unknown[]): void;
+    static info(...args: unknown[]): void;
+    static error(...args: unknown[]): void;
+    static table(...args: unknown[]): void;
+    static time(...args: any): void;
+    static timeEnd(...args: any): void;
+}
+
+/**
+ * Create a string of the form 'HOURS.MINUTES.SECONDS.MILLISECONDS'.
+ */
+declare function timeToString(): string;
+declare function timeUTCToString(): string;
+
+declare function cleanupFileName(value: string): string;
+
+declare function makePath(...value: string[]): string;
+
+declare function normalizePath(value: string): string;
+
+interface Size {
+    w: number;
+    h: number;
+}
+
+interface Coords {
+    x: number;
+    y: number;
+}
+
+interface Rect extends Size, Coords {
+}
+
+interface Area extends Rect {
+    scale: number;
+}
+
+declare function expandOverRectangle(objectRect: Rect, areaRect: Rect): Area;
+
+declare function fitIntoRectangle(objectRect: Rect, areaRect: Rect, round?: boolean, fixedRatio?: number | null): Area;
+
+interface LoadArgs {
+    order: number;
+    extra: any;
+    item?: HTMLImageElement;
+    useXhr?: boolean;
+    path: string;
+    onLoadEnd: (data: LoadArgs) => void;
+    onLoadStart: (data: ProgressEvent) => void;
+    onProgress: (data: ProgressEvent) => void;
+    id?: string;
+    img?: HTMLImageElement;
+    error?: boolean;
+    fallBack?: string;
+    resolutionId: number | string | null;
+}
+
+interface LoadArgsTmp extends LoadArgs {
+    xhr?: XMLHttpRequest;
+}
+
+declare const ImageOutput: {
+    readonly CANVAS: "canvas";
+    readonly PNG: "image/png";
+    readonly WEBP: "image/webp";
+    readonly JPG: "image/jpeg";
+};
+type ImageOutputValues = (typeof ImageOutput)[keyof typeof ImageOutput];
+
+declare class BatchLoader {
+    private maximumSlotsNumber;
+    private queue;
+    private slots;
+    private _whenDone;
+    clear(): void;
+    /**
+     * new settings
+     * you must pass new settings
+     * @param sett
+     */
+    setSettings(sett: any): void;
+    /**
+     * execute with a chosen file
+     * @param id
+     * @param func
+     */
+    withItem(id: string, func: (item: LoadArgs) => any): boolean;
+    remove(id: string): LoadArgs[];
+    /**
+     * executes when all files are downloaded
+     * @param cb
+     */
+    whenDone(cb: any): void;
+    load(args: LoadArgs[]): {
+        path: string;
+        self?: any;
+        id: string;
+    }[];
+    /**
+     * operates with one file
+     * @param item
+     * @private
+     */
+    private add;
+    private sortByOrder;
+    private loadEnd;
+    private checkSlots;
+    /**
+     * get Item By id for interaction with files in this.queue
+     * @param id
+     * @private
+     */
+    private getById;
+    private getXmlHttp;
+}
+
+declare const debounce: <T extends (...args: any[]) => any>(fn: T, ms?: number) => (this: any, ...args: any[]) => void;
+
+declare const KeyboardNumericCode: {
+    readonly Backspace: 8;
+    readonly Tab: 9;
+    readonly Numpad5: 12;
+    readonly NumpadEnter: 13;
+    readonly ShiftRight: 16;
+    readonly ControlRight: 17;
+    readonly ControlLeft: 17;
+    readonly AltRight: 18;
+    readonly Escape: 27;
+    readonly Space: 32;
+    readonly Numpad9: 33;
+    readonly Numpad3: 34;
+    readonly Numpad1: 35;
+    readonly Numpad7: 36;
+    readonly Numpad4: 37;
+    readonly Numpad8: 38;
+    readonly Numpad6: 39;
+    readonly Numpad2: 40;
+    readonly Numpad0: 45;
+    readonly NumpadDecimal: 46;
+    readonly Digit0: 48;
+    readonly Digit1: 49;
+    readonly Digit2: 50;
+    readonly Digit3: 51;
+    readonly Digit4: 52;
+    readonly Digit5: 53;
+    readonly Digit6: 54;
+    readonly Digit7: 55;
+    readonly Digit8: 56;
+    readonly Digit9: 57;
+    readonly KeyA: 65;
+    readonly KeyB: 66;
+    readonly KeyC: 67;
+    readonly KeyD: 68;
+    readonly KeyE: 69;
+    readonly KeyF: 70;
+    readonly KeyG: 71;
+    readonly KeyH: 72;
+    readonly KeyI: 73;
+    readonly KeyJ: 74;
+    readonly KeyK: 75;
+    readonly KeyL: 76;
+    readonly KeyM: 77;
+    readonly KeyN: 78;
+    readonly KeyO: 79;
+    readonly KeyP: 80;
+    readonly KeyQ: 81;
+    readonly KeyR: 82;
+    readonly KeyS: 83;
+    readonly KeyT: 84;
+    readonly KeyU: 85;
+    readonly KeyV: 86;
+    readonly KeyW: 87;
+    readonly KeyX: 88;
+    readonly KeyY: 89;
+    readonly KeyZ: 90;
+    readonly MetaLeft: 91;
+    readonly ContextMenu: 93;
+    readonly NumpadMultiply: 106;
+    readonly NumpadAdd: 107;
+    readonly NumpadSubtract: 109;
+    readonly NumpadDivide: 111;
+    readonly F1: 112;
+    readonly F2: 113;
+    readonly F3: 114;
+    readonly F4: 115;
+    readonly F5: 116;
+    readonly F6: 117;
+    readonly F7: 118;
+    readonly F8: 119;
+    readonly F9: 120;
+    readonly F10: 121;
+    readonly F11: 122;
+    readonly F12: 123;
+    readonly NumLock: 144;
+    readonly ScrollLock: 145;
+    readonly Semicolon: 186;
+    readonly Equal: 187;
+    readonly Comma: 188;
+    readonly Minus: 189;
+    readonly Period: 190;
+    readonly Slash: 191;
+    readonly Backquote: 192;
+    readonly BracketLeft: 219;
+    readonly Backslash: 220;
+    readonly BracketRight: 221;
+    readonly Quote: 222;
+    readonly IntlBackslash: 226;
+    readonly ArrowUp: 38;
+    readonly ArrowDown: 40;
+    readonly ArrowLeft: 37;
+    readonly ArrowRight: 39;
+};
+type IKeyName = keyof typeof KeyboardNumericCode;
+type IKeyCode = (typeof KeyboardNumericCode)[IKeyName];
+type InvertedKeyMapType = {
+    [K in IKeyName as (typeof KeyboardNumericCode)[K]]: K;
+};
+declare const InvertedKeyMap: InvertedKeyMapType;
+declare const KeyboardStringCode: { [K in IKeyName]: K; };
+
+declare function serialize(obj: any): string;
+
+declare const saveToLocalDrive: (uri: string, name: string) => any;
+
+declare function sleep(time: number): Promise<unknown>;
+
+declare function trimLastSlashFromUrl(baseUrl: string): string | null | undefined;
+
+/**
+ * SingleTone Private class.
+ * Event-Driving pattern for sending signals from component to component.
+ */
+declare class SignalClass {
+    private static eventBus;
+    constructor();
+    /**
+     * It is not recommended to use this class directly.
+     * use the sendSignal functions instead.
+     * those wrappers are more convenient and provide a better type safety.
+     */
+    broadcast<K, D>(key: K, data?: D): void;
+    /**
+     * It is not recommended to use this class directly.
+     * use the fromSignal functions instead.
+     * those wrappers are more convenient and provide a better type safety.
+     */
+    on<K, D = any>(key: K): Observable<D>;
+}
+declare const Signal: SignalClass;
+
+declare function generateUuid(): string;
+
+declare function shortHash<T>(data: T, shorten?: boolean): string;
+declare function shortHash(data: null | undefined, shorten?: boolean): null;
+
+declare const isDesktop: () => boolean;
+
+declare const media: (query: string) => rxjs.Observable<boolean>;
+
+declare function getCanvasCached(id: string): {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+};
+
+declare function getSnapshot(imageElement: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap, maxWidth?: number, output?: ImageOutputValues, quality?: number): HTMLCanvasElement | string;
+
+declare function loadImage(url: string): Promise<HTMLImageElement>;
+
+/**
+ * USE DownloadImage instead!
+ * @deprecated use DownloadImage instead!
+ * @param imageSource
+ * @param name
+ * @param width
+ * @param format
+ */
+declare function SaveImage(imageSource: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap | string, name: string, width?: number, format?: string | ImageOutputValues): any;
+/**
+ * @param imageSource
+ * @param string name
+ * @param number width
+ * @param string format
+ */
+declare const DownloadImage: typeof SaveImage;
+
+/**
+ * Calculates the index at which the `value` should be inserted into the `array` to maintain its
+ * sorted order. This function performs a binary search with a complexity of O(log n), making it
+ * efficient for large datasets. It assumes that the input array is sorted in ascending order and
+ * contains comparable elements.
+ *
+ * Note: The function is designed to handle arrays with lengths up to a maximum of `HALF_MAX_ARRAY_LENGTH`
+ * to ensure the search operation remains within JavaScript's maximum array index limit.
+ *
+ * @param {any[]} array The sorted array into which the value should be inserted. The array elements
+ *                      should be comparable with the `value` using less-than and greater-than operations.
+ * @param {number} value The value to insert into the array. This function assumes that `array` is sorted
+ *                       in ascending order and will find the correct position for `value` accordingly.
+ * @returns {number} The index at which the `value` should be inserted into `array` to maintain its sorted order.
+ *                   If the `array` is empty or if `value` is less than or equal to all elements in `array`,
+ *                   returns 0. If `value` is greater than all elements in `array`, returns the length of `array`.
+ * @example
+ * // returns 2
+ * baseSortedIndex([1, 3, 4], 3);
+ *
+ * @example
+ * // returns 1
+ * baseSortedIndex([1, 2, 3], 2);
+ */
+declare function baseSortedIndex(array: number[], value: number): number;
+
+/**
+ * Calculates the median of an array of numbers.
+ *
+ * The median is the middle value of a sorted list of numbers. If the list has an even number
+ * of elements, the median is the average of the two middle numbers.
+ *
+ * @param numbers - An array of numbers for which the median will be calculated.
+ * @returns The median value as a number, or `null` if the array is empty.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [3, 1, 4, 2];
+ * const median = calculateMedian(numbers);
+ * console.log(median); // Output: 2.5
+ * ```
+ */
+declare function calculateMedian(numbers: number[]): number;
+
+/**
+ * Computes a circular index within a given range.
+ *
+ * This function ensures that the index wraps around within the range of 0 to `totalItems - 1`.
+ * It uses the `clampf` function to clamp the result within the valid range.
+ *
+ * @param index - The current index to be wrapped.
+ * @param totalItems - The total number of items in the range.
+ * @returns The wrapped index within the range of 0 to `totalItems - 1`.
+ *
+ * @example
+ * ```typescript
+ * import { circularIndex } from './circularIndex';
+ *
+ * // Example 1: Basic usage
+ * const index1 = circularIndex(5, 5);
+ * console.log(index1); // Output: 0
+ *
+ * // Example 2: Index greater than totalItems
+ * const index2 = circularIndex(6, 5);
+ * console.log(index2); // Output: 1
+ *
+ * // Example 3: Negative index
+ * const index3 = circularIndex(-2, 5);
+ * console.log(index3); // Output: 3
+ *
+ * // Example 4: Large Negative index
+ * const index4 = circularIndex(-6, 5);
+ * console.log(index4); // Output: 4
+ *
+ * // Example 5: Index equal to totalItems
+ * const index5 = circularIndex(1, 1);
+ * console.log(index5); // Output: 0
+ */
+declare function circularIndex(index: number, totalItems: number): number;
+
+/**
+ * Clamps value between min and max;
+ * @param min minValue
+ * @param max maxValue
+ * @param value inputValue
+ * @returns number
+ */
+declare function clampf(min: number, max: number, value: number): number;
+
+declare function degreesToRadians(degrees: number): number;
+declare function radiansToDegrees(radians: number): number;
+
+/**
+ * Checks if floating-point number `A` is less than `B` considering a small margin of error.
+ *
+ * @param A - The first floating-point number to compare.
+ * @param B - The second floating-point number to compare.
+ * @param Epsilon - Optional custom epsilon value for comparison. Defaults to `EPSILON` if not provided.
+ * @returns `true` if `A` is less than `B` considering the epsilon margin, otherwise `false`.
+ *
+ * @example
+ * ```
+ * const result = fpIsALessThanB(0.0034, 0.0066); // true
+ * ```
+ */
+declare function fpIsALessThanB(A: number, B: number, Epsilon?: number): boolean;
+/**
+ * Checks if floating-point number `A` is greater than `B` considering a small margin of error.
+ *
+ * @param A - The first floating-point number to compare.
+ * @param B - The second floating-point number to compare.
+ * @param Epsilon - Optional custom epsilon value for comparison. Defaults to `EPSILON` if not provided.
+ * @returns `true` if `A` is greater than `B` considering the epsilon margin, otherwise `false`.
+ *
+ * @example
+ * ```
+ * const result = fpIsAGreaterThanB(0.0066, 0.0034); // true
+ * ```
+ */
+declare function fpIsAGreaterThanB(A: number, B: number, Epsilon?: number): boolean;
+/**
+ * Checks if floating-point number `A` is approximately the same as `B` considering a small margin of error.
+ *
+ * @param A - The first floating-point number to compare.
+ * @param B - The second floating-point number to compare.
+ * @param Epsilon - Optional custom epsilon value for comparison. Defaults to `EPSILON` if not provided.
+ * @returns `true` if `A` is approximately equal to `B` considering the epsilon margin, otherwise `false`.
+ *
+ * @example
+ * ```
+ * const result = fpIsASameAsB(0.005, 0.0051); // true
+ * ```
+ */
+declare function fpIsASameAsB(A: number, B: number, Epsilon?: number): boolean;
+
+/**
+ * Performs an inverse linear interpolation.
+ *
+ * Given a range defined by `min` and `max`, this function calculates the
+ * interpolation factor (or percentage) of `value` within that range. Optionally,
+ * it can clamp the result to be between 0 and 1 to ensure the return value is
+ * within the range of a standard lerp operation.
+ *
+ * @param {number} min - The minimum value of the interpolation range.
+ * @param {number} max - The maximum value of the interpolation range.
+ * @param {number} value - The value to interpolate.
+ * @param {boolean} [clampToNormal=false] - Whether to clamp the result between 0 and 1.
+ * @returns {number} The interpolation factor of `value` between `min` and `max`.
+ * If `clampToNormal` is true, the result is clamped between 0 and 1.
+ * If the difference between `min` and `max` is 0, returns 1 to avoid division by zero.
+ */
+declare function inverseLerp(min: number, max: number, value: number, clampToNormal?: boolean): number;
+
+/**
+ * @param min minimums
+ * @param max maximums
+ * @param value current float value in 0-1 range
+ * @returns clamped value
+ */
+declare function lerp(min: number, max: number, value: number): number;
+
+/**
+ * A Mutex class to handle mutual exclusion locks, ensuring that only one asynchronous task can execute a critical section at a time.
+ *
+ * @example
+ * const mutex = new Mutex();
+ *
+ * async function task(name: string, duration: number) {
+ *   console.log(`${name} waiting to acquire mutex`);
+ *   const release = await mutex.acquire();
+ *   console.log(`${name} acquired mutex`);
+ *   await new Promise(resolve => setTimeout(resolve, duration));
+ *   console.log(`${name} releasing mutex`);
+ *   release();
+ * }
+ *
+ * task('Task 1', 1000);
+ * task('Task 2', 2000);
+ * task('Task 3', 1500);
+ * task('Task 4', 500);
+ *
+ * Outputs
+ * [LOG]: "Task 1 waiting to acquire mutex"
+ * [LOG]: "Task 2 waiting to acquire mutex"
+ * [LOG]: "Task 3 waiting to acquire mutex"
+ * [LOG]: "Task 4 waiting to acquire mutex"
+ * [LOG]: "Task 1 acquired mutex"
+ * [LOG]: "Task 1 releasing mutex"
+ * [LOG]: "Task 2 acquired mutex"
+ * [LOG]: "Task 2 releasing mutex"
+ * [LOG]: "Task 3 acquired mutex"
+ * [LOG]: "Task 3 releasing mutex"
+ * [LOG]: "Task 4 acquired mutex"
+ * [LOG]: "Task 4 releasing mutex"
+ */
+declare class Mutex {
+    private mutex;
+    /**
+     * Acquires the mutex, returning a promise that resolves when the mutex is acquired.
+     * The returned promise provides a release function that should be called to release the mutex.
+     * @returns A promise that resolves with a release function.
+     */
+    acquire(): Promise<() => void>;
+}
+
+/**
+ * A Semaphore controls access to a resource that can handle a limited number of concurrent operations.
+ *
+ * @example
+ * const semaphore = new Semaphore(2);
+ *
+ * async function task(name: string, duration: number) {
+ *   console.log(`${name} waiting to acquire semaphore`);
+ *   await semaphore.acquire();
+ *   console.log(`${name} acquired semaphore`);
+ *   await new Promise(resolve => setTimeout(resolve, duration));
+ *   console.log(`${name} releasing semaphore`);
+ *   semaphore.release();
+ * }
+ *
+ * task('Task 1', 1000);
+ * task('Task 2', 2000);
+ * task('Task 3', 1500);
+ * task('Task 4', 500);
+ *
+ * Outputs
+ * [LOG]: "Task 1 waiting to acquire semaphore"
+ * [LOG]: "Task 2 waiting to acquire semaphore"
+ * [LOG]: "Task 3 waiting to acquire semaphore"
+ * [LOG]: "Task 4 waiting to acquire semaphore"
+ * [LOG]: "Task 1 acquired semaphore"
+ * [LOG]: "Task 2 acquired semaphore"
+ * [LOG]: "Task 1 releasing semaphore"
+ * [LOG]: "Task 3 acquired semaphore"
+ * [LOG]: "Task 2 releasing semaphore"
+ * [LOG]: "Task 4 acquired semaphore"
+ * [LOG]: "Task 4 releasing semaphore"
+ * [LOG]: "Task 3 releasing semaphore"
+ */
+declare class Semaphore {
+    private readonly maxConcurrency;
+    private tasks;
+    private currentCount;
+    constructor(maxConcurrency: number);
+    acquire(): Promise<void>;
+    release(): void;
+}
+
+declare class TaskRunner {
+    private mutex;
+    runTask(name: string, task: () => Observable<string | null>): Observable<string | null>;
+}
+
+type TruthyTypesOf$1<T> = T extends false | '' | 0 | null | undefined ? never : T;
+type FalsyTypesOf<T> = T extends false | '' | 0 | null | undefined ? T : never;
+type EmptyTypesOf<T> = T extends undefined | null | object | '' ? T : never;
+type NonEmptyTypesOf<T> = T extends undefined | null | object | '' ? never : T;
+/**
+ * The Boolean object represents a truth value: true or false.
+ * @param value
+ * @constructor
+ * Returns:boolean
+ */
+declare const Truthy: <T>(value: T) => value is TruthyTypesOf$1<T>;
+/**
+ * The Boolean object represents an INVERSE truth value: true or false.
+ * @param value
+ * @constructor
+ * Returns:boolean
+ */
+declare const Falsy$1: <T>(value: T) => value is FalsyTypesOf<T>;
+/**
+ * Checks if a value is empty.
+ *
+ * @param {any} value - The value to check.
+ * @return {boolean} Returns true if the value is empty, otherwise false.
+ */
+declare const IsEmpty: <T>(value: T) => value is EmptyTypesOf<T>;
+declare const NotEmpty: <T>(value: T) => value is NonEmptyTypesOf<T>;
+declare const isDefined: <T>(arg: T | null | undefined) => arg is T;
+declare const isNotDefined: <T>(arg: T | null | undefined) => arg is null | undefined;
+declare const isJSON: (str: string) => boolean;
+declare const isEmpty: (value: any) => boolean;
+declare function isAllValuesTruthy<T extends string, K>(value: Record<T, K>): boolean;
+
+/**
+ * Converts a given value to a string suitable for search comparisons.
+ * The resulting string is in lowercase, with consecutive spaces replaced by underscores.
+ * The function uses a cache to improve performance by storing and reusing the results of previous conversions.
+ *
+ * @param {any} value - The value to be converted to a search-friendly string.
+ * It can be of any type, but it will be coerced to a string if not already one.
+ *
+ * @param {boolean} caseSensitive - A flag indicating whether the comparison should be case-sensitive.
+ * If set to true, the function will perform case-sensitive comparisons, preserving the original casing of input strings.
+ * If set to false (default), the function will convert the input strings to lowercase for case-insensitive comparisons
+ *
+ * @returns {string} The processed string, which is trimmed, converted to lowercase (unless caseSensitive is true),
+ * and has all sequences of spaces replaced with underscores. This string is either
+ * retrieved from the cache or freshly computed and then cached.
+ *
+ */
+declare function textForSearch(value: unknown, caseSensitive?: boolean): string;
+
+/**
+ * Builds a predicate that checks whether a record matches **all** provided criteria.
+ *
+ * Behavior:
+ * - Only keys with **defined** values in `criteria` are considered; keys with `undefined` are ignored.
+ * - Both the criterion value and the corresponding record value are normalized using `textForSearch(value, caseSensitive)`,
+ *   then compared for **equality** (not substring/contains).
+ * - By default (`caseSensitive = false`), comparisons are case-insensitive and tolerant to extra spacing
+ *   (per `textForSearch`). When `caseSensitive = true`, comparisons preserve original casing.
+ * - If **no** criteria have defined values, the resulting predicate always returns **false**.
+ *
+ * @remarks
+ * **Nested object stringification (runtime edge case):**
+ * Although the TypeScript types constrain comparisons to primitive fields via `ISearchable<T>`,
+ * at runtime any non-primitive value that slips through (e.g., due to loose typing) will be coerced to a string
+ * before normalization. For example:
+ *
+ * ```ts
+ * // Runtime behavior with nested objects (typing omitted for brevity)
+ * const record = { age: 20, test: { hello: 'world' } } as any;
+ * // textForSearch(record.test, false) => "[object_object]" (e.g., "[object Object]" normalized)
+ * const criteria = { age: 20, test: "[object_object]" } as any;
+ * const matches = where<any>(criteria)(record);
+ * // matches === true
+ * ```
+ *
+ * In other words, `{ hello: 'world' }` is interpreted as the string `"[object_object]"` after normalization,
+ * so a criterion with `test: "[object_object]"` will successfully match.
+ *
+ * @typeParam T - The object type whose **primitive** fields are comparable via `ISearchable<T>`.
+ *
+ * @param criteria - A partial set of key–value pairs over `ISearchable<T>` to match against.
+ *   Only keys with defined values participate in the comparison.
+ * @param caseSensitive - Whether comparisons should be case-sensitive. Defaults to `false`.
+ *
+ * @returns A predicate `(record: ISearchable<T>) => boolean` that is `true` iff the record matches **all** criteria.
+ *
+ * @example
+ * type Item = { name: string; category: string; note?: string };
+ * const items: Item[] = [
+ *   { name: "Apple",  category: "Fruit" },
+ *   { name: "Carrot", category: "Vegetable" },
+ *   { name: "Banana", category: "Fruit" }
+ * ];
+ *
+ * // Case-insensitive equality match on category ("fruit" matches "Fruit")
+ * const isFruit = where<Item>({ category: "fruit" });
+ * const fruits = items.filter(isFruit);
+ * // → [{ name: "Apple", category: "Fruit" }, { name: "Banana", category: "Fruit" }]
+ *
+ * // Empty criteria → predicate always false
+ * const matchNothing = where<Item>({});
+ * items.filter(matchNothing); // → []
+ */
+declare function where<T extends object>(criteria: Input<T>, caseSensitive?: boolean): (record: ISearchable<T>) => boolean;
+/**
+ * Builds a predicate that is the logical **negation** of `where`.
+ *
+ * Behavior mirrors `where(criteria, caseSensitive)` but returns `true` when a record **does not**
+ * satisfy all criteria. Notable edge cases:
+ * - If `criteria` has no defined values (i.e., `where` would always return `false`), this negated predicate
+ *   will always return **true**.
+ * - **Nested object stringification (runtime edge case):** If a nested object is compared against a criterion
+ *   like `"[object_object]"` (after normalization), the original `where` would return `true`, so `whereNot` will return `false`.
+ *
+ * @typeParam T - The object type whose **primitive** fields are comparable via `ISearchable<T>`.
+ *
+ * @param criteria - Same as in `where`.
+ * @param caseSensitive - Same as in `where`. Defaults to `false`.
+ *
+ * @returns A predicate `(record: ISearchable<T>) => boolean` that is `true` iff the record **fails** the `where` check.
+ *
+ * @example
+ * type Item = { name: string; category: string };
+ * const items: Item[] = [
+ *   { name: "Apple",  category: "Fruit" },
+ *   { name: "Carrot", category: "Vegetable" }
+ * ];
+ *
+ * const isNotFruit = whereNot<Item>({ category: "fruit" });
+ * items.filter(isNotFruit);
+ * // → [{ name: "Carrot", category: "Vegetable" }]
+ */
+declare function whereNot<T extends object>(criteria: Input<T>, caseSensitive?: boolean): (record: ISearchable<T>) => boolean;
+type HasPrimitivePartKeys<T> = {
+    [K in keyof T]: Extract<T[K], Primitive> extends never ? never : K;
+}[keyof T];
+type ISearchable<T> = {
+    [K in HasPrimitivePartKeys<T>]: Extract<T[K], Primitive>;
+};
+type Input<T> = Partial<TruthyTypesOf<ISearchable<T>>>;
+type Primitive = string | number | bigint | boolean | symbol | null | undefined;
+type TruthyTypesOf<T> = T extends Falsy ? never : T;
+type Falsy = null | undefined | false | 0 | -0 | 0n | '';
+
+/**
+ * Emits the most recent value emitted by the source Observable after a
+ * specified time span has passed without another source emission.
+ *
+ * This is a combination of `debounceTime` and `auditTime` operators.
+ *
+ * The leading value is emitted immediately, and trailing values are debounced.
+ *
+ * @param dueTime The time to wait before emitting the last value.
+ * @param scheduler The scheduler to use for the timeout.
+ * @returns A function that returns an Observable that mirrors the source Observable, but applies the specified debouncing.
+ */
+declare function leadingTrailingDebounceTime<T>(dueTime: number, scheduler?: SchedulerLike): (source: Observable<T>) => Observable<T>;
+
+/**
+ * Creates an observable that emits values transitioning smoothly from the start value to the end value over a specified duration.
+ * The transition is performed using linear interpolation (lerp) and clamped to the range [0, 1].
+ *
+ * @param {number} start - The starting value of the transition.
+ * @param {number} end - The ending value of the transition.
+ * @param {number} duration - The duration of the transition in milliseconds.
+ * @returns {Observable<number>} An observable that emits the interpolated values from start to end over the specified duration.
+ */
+declare const smoothTransition: (start: number, end: number, duration: number) => Observable<number>;
+
+declare const tapLog: <T>(text: string, ...args: any) => ((source: Observable<T>) => Observable<T>);
+
+/**
+ * Adds required number of symbols before input
+ * @param input input string
+ * @param size amount of total symbols
+ * @param symbol filler
+ * @returns string
  */
-/// <amd-module name="@3dsource/utils" />
-export * from './public-api';
+declare function pad(input: number | string, size: number, symbol?: string): string;
+
+export { BatchLoader, CMYKtoRGB, COLOR_CODES, CSV2Array, CSV2Records, DOCUMENT_ROOT, DownloadImage, Falsy$1 as Falsy, HEXtoRGB, HSVtoRGB, ImageOutput, InvertedKeyMap, IsEmpty, KeyboardNumericCode, KeyboardStringCode, Logger, Mutex, NotEmpty, ObjectToCSV, RGBtoCMYK, RGBtoHEX, RGBtoHSV, SaveImage, Semaphore, Signal, TaskRunner, Truthy, baseSortedIndex, calculateMedian, circularIndex, clampf, cleanupFileName, debounce, degreesToRadians, expandOverRectangle, fitIntoRectangle, fpIsAGreaterThanB, fpIsALessThanB, fpIsASameAsB, generateUuid, getCanvasCached, getSnapshot, hsv, inverseLerp, isAllValuesTruthy, isDefined, isDesktop, isEmpty, isJSON, isLocalhost, isNotDefined, leadingTrailingDebounceTime, lerp, loadImage, makePath, max, media, min, normalizePath, overlay, pad, radiansToDegrees, rgb, saveToLocalDrive, serialize, shortHash, sleep, smoothTransition, sub, subtract, sum, tapLog, textForSearch, timeToString, timeUTCToString, toRGB, toRGBA, trimLastSlashFromUrl, where, whereNot };
+export type { Area, Coords, IKeyCode, IKeyName, ImageOutputValues, LoadArgs, LoadArgsTmp, Rect, Size };