@3dsource/utils 1.0.4 → 1.0.5

package/fesm2022/3dsource-utils.mjs

@@ -0,0 +1,1793 @@
+import { from, switchMap, finalize, asyncScheduler, Observable, timer, animationFrameScheduler, interval } from 'rxjs';
+import { map, distinctUntilChanged, tap } from 'rxjs/operators';
+
+/**
+ * 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
+ *
+ **/
+function CMYKtoRGB(c, m, y, k) {
+    c = 255 - c;
+    m = 255 - m;
+    y = 255 - y;
+    k = 255 - k;
+    return [
+        ((255 - c) * (255 - k)) / 255,
+        ((255 - m) * (255 - k)) / 255,
+        ((255 - y) * (255 - k)) / 255,
+    ];
+}
+
+function HEXtoRGB(color) {
+    if (typeof color === 'string') {
+        color = parseInt(color.replace('#', ''), 16);
+    }
+    const r = (color >> 16) & 255;
+    const g = (color >> 8) & 255;
+    const b = color & 255;
+    return { r: r, g: g, b: b };
+}
+
+/**
+ *  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
+ **/
+function rgb(r, g, b) {
+    return (r << 16) | (g << 8) | b;
+}
+
+/* eslint-disable prefer-const */
+/**
+ * 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]
+ **/
+function HSVtoRGB(h, s, v) {
+    let r = 0, g = 0, b = 0;
+    let i, x, y, z;
+    if (s < 0) {
+        s = 0;
+    }
+    if (s > 1) {
+        s = 1;
+    }
+    if (v < 0) {
+        v = 0;
+    }
+    if (v > 1) {
+        v = 1;
+    }
+    h = h % 360;
+    if (h < 0) {
+        h += 360;
+    }
+    h /= 60;
+    i = h >> 0;
+    x = v * (1 - s);
+    y = v * (1 - s * (h - i));
+    z = v * (1 - s * (1 - h + i));
+    switch (i) {
+        case 0:
+            r = v;
+            g = z;
+            b = x;
+            break;
+        case 1:
+            r = y;
+            g = v;
+            b = x;
+            break;
+        case 2:
+            r = x;
+            g = v;
+            b = z;
+            break;
+        case 3:
+            r = x;
+            g = y;
+            b = v;
+            break;
+        case 4:
+            r = z;
+            g = x;
+            b = v;
+            break;
+        case 5:
+            r = v;
+            g = x;
+            b = y;
+            break;
+    }
+    return [(r * 255) >> 0, (g * 255) >> 0, (b * 255) >> 0];
+}
+
+/* eslint-disable prefer-spread */
+/**
+ * HSV calculated from the numbers of each RGB color value.
+ * @ 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 obtained from the RGB color value for each indicating the number
+ **/
+function hsv(h, s, v) {
+    return rgb.apply(null, HSVtoRGB(h, s, v));
+}
+
+/**
+ * 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]
+ **/
+function toRGB(rgb) {
+    const r = (rgb >> 16) & 0xff;
+    const g = (rgb >> 8) & 0xff;
+    const b = rgb & 0xff;
+    return [r, g, b];
+}
+
+/**
+ * Comparison (light).
+ * 2 RGB single number that indicates (0x000000 0xFFFFFF up from) to compare,
+ * RGB values combined with higher returns to their numbers.
+ * @ Param col1 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Param col2 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Return comparison (light) value
+ **/
+function max(col1, col2) {
+    const c1 = toRGB(col1);
+    const c2 = toRGB(col2);
+    const r = Math.max(c1[0], c2[0]);
+    const g = Math.max(c1[1], c2[1]);
+    const b = Math.max(c1[2], c2[2]);
+    return (r << 16) | (g << 8) | b;
+}
+
+/**
+ * Comparison (dark).
+ * 2 RGB single numbers that indicate (0x000000 0xFFFFFF up from) to compare,
+ * RGB lower combined returns a numeric value for each number.
+ * @ Param col1 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Param col2 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Return comparison (dark) values
+ **/
+function min(col1, col2) {
+    const c1 = toRGB(col1);
+    const c2 = toRGB(col2);
+    const r = Math.min(c1[0], c2[0]);
+    const g = Math.min(c1[1], c2[1]);
+    const b = Math.min(c1[2], c2[2]);
+    return (r << 16) | (g << 8) | b;
+}
+
+/**
+ *
+ There are two part of formula:
+ First part: If Lower Layer Value > 127.5, then do the following -
+ Value Unit = (255-Lower Layer Value)/127.5
+ Min Value = Lower Layer Value - (255-Lower Layer Value)
+ Overlay = (Upper Layer Value * Value Unit) + Min Value
+ Second part: If Lower Layer Value < 127.5, then do the following -
+ Value Unit=Lower Layer Value/127.5
+
+ Overlay = Upper Layer Value * Value Unit
+ * @param {number} col1
+ * @param {number} col2
+ * @return {number}
+ */
+function overlay(col1, col2) {
+    const c1 = toRGB(col1);
+    const c2 = toRGB(col2);
+    const r = Math.max(c1[0], c2[0]);
+    const g = Math.max(c1[1], c2[1]);
+    const b = Math.max(c1[2], c2[2]);
+    return (r << 16) | (g << 8) | b;
+}
+
+/**
+ * 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]
+ **/
+function RGBtoCMYK(r, g, b) {
+    let c = 0;
+    let m = 0;
+    let y = 0;
+    let k = 0;
+    c = 255 - r;
+    m = 255 - g;
+    y = 255 - b;
+    k = 255;
+    if (c < k) {
+        k = c;
+    }
+    if (m < k) {
+        k = m;
+    }
+    if (y < k) {
+        k = y;
+    }
+    if (k === 255) {
+        c = 0;
+        m = 0;
+        y = 0;
+    }
+    else {
+        c = Math.round((255 * (c - k)) / (255 - k));
+        m = Math.round((255 * (m - k)) / (255 - k));
+        y = Math.round((255 * (y - k)) / (255 - k));
+    }
+    return [c, m, y, k];
+}
+
+function RGBtoHEX(r, g, b) {
+    let redColor = r.toString(16);
+    let greenColor = g.toString(16);
+    let blackColor = b.toString(16);
+    if (redColor.length === 1) {
+        redColor = '0' + redColor;
+    }
+    if (greenColor.length === 1) {
+        greenColor = '0' + greenColor;
+    }
+    if (blackColor.length === 1) {
+        blackColor = '0' + blackColor;
+    }
+    return (redColor + greenColor + blackColor).toUpperCase();
+}
+
+/**
+ * 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]
+ **/
+function RGBtoHSV(r, g, b) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    let h = 0, s = 0, v = 0;
+    let x, y;
+    if (r >= g)
+        x = r;
+    else
+        x = g;
+    if (b > x)
+        x = b;
+    if (r <= g)
+        y = r;
+    else
+        y = g;
+    if (b < y)
+        y = b;
+    v = x;
+    const c = x - y;
+    if (x === 0)
+        s = 0;
+    else
+        s = c / x;
+    if (s !== 0) {
+        if (r === x) {
+            h = (g - b) / c;
+        }
+        else {
+            if (g === x) {
+                h = 2 + (b - r) / c;
+            }
+            else {
+                if (b === x) {
+                    h = 4 + (r - g) / c;
+                }
+            }
+        }
+        h = h * 60;
+        if (h < 0)
+            h = h + 360;
+    }
+    return [h, s, v];
+}
+
+/**
+ * Subtractive.
+ * 2 RGB single numbers that indicate (0x000000 0xFFFFFF up from) Return the value
+ * of the subtractive color.
+ * @ Param col1 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Param col2 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Return the subtractive
+ **/
+function sub(col1, col2) {
+    const c1 = toRGB(col1);
+    const c2 = toRGB(col2);
+    const r = Math.max(c1[0] - c2[0], 0);
+    const g = Math.max(c1[1] - c2[1], 0);
+    const b = Math.max(c1[2] - c2[2], 0);
+    return (r << 16) | (g << 8) | b;
+}
+
+/**
+ * Subtraction.
+ * 2 RGB single number that indicates (0x000000 0xFFFFFF up from) is subtracted
+ * from the return numbers.
+ * @ Param col1 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Param col2 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Return value subtracted Blend
+ **/
+function subtract(col1, col2) {
+    const colA = toRGB(col1);
+    const colB = toRGB(col2);
+    const r = Math.max(Math.max(colB[0] - (256 - colA[0]), colA[0] - (256 - colB[0])), 0);
+    const g = Math.max(Math.max(colB[1] - (256 - colA[1]), colA[1] - (256 - colB[1])), 0);
+    const b = Math.max(Math.max(colB[2] - (256 - colA[2]), colA[2] - (256 - colB[2])), 0);
+    return (r << 16) | (g << 8) | b;
+}
+
+/**
+ * Additive color.
+ * 2 RGB single numbers that indicate (0x000000 0xFFFFFF up from) Return the value
+ * of the additive mixture.
+ * @ Param col1 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Param col2 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Return the additive color
+ **/
+function sum(col1, col2) {
+    const c1 = toRGB(col1);
+    const c2 = toRGB(col2);
+    const r = Math.min(c1[0] + c2[0], 255);
+    const g = Math.min(c1[1] + c2[1], 255);
+    const b = Math.min(c1[2] + c2[2], 255);
+    return (r << 16) | (g << 8) | b;
+}
+
+function toRGBA(rgba) {
+    const a = (rgba >> 24) & 0xff;
+    const r = (rgba >> 16) & 0xff;
+    const g = (rgba >> 8) & 0xff;
+    const b = rgba & 0xff;
+    return [r, g, b, a];
+}
+
+const COLOR_CODES = {
+    TO_UNREAL: ['#ffffff', '#005912', `UNREAL <-`],
+    TAP_LOG: ['#ffff00', '#1976d2', ' [TAPLOG]'],
+    FROM_UNREAL: ['#ffff00', '#898989', 'UNREAL ->'],
+    FROM_UNREAL_ERROR: ['#ffffff', '#ff0000', 'UNREAL ERROR ->'],
+    FROM_CIRRUS: ['#ffffff', '#ef702b', 'CIRRUS ->'],
+    FROM_CIRRUS_ERROR: ['#ffffff', '#ff0000', 'CIRRUS ->'],
+    TO_CIRRUS: ['#ffffff', '#3c9738', 'CIRRUS <-'],
+};
+
+function CSV2Array(strData, strDelimiter) {
+    // Check to see if the delimiter is defined. If not,
+    // then default to comma.
+    strDelimiter = strDelimiter || ',';
+    // Create a regular expression to parse the CSV values.
+    const objPattern = new RegExp(
+    // Delimiters.
+    '(\\' +
+        strDelimiter +
+        '|\\r?\\n|\\r|^)' +
+        // Quoted fields.
+        '(?:"([^"]*(?:""[^"]*)*)"|' +
+        // Standard fields.
+        '([^"\\' +
+        strDelimiter +
+        '\\r\\n]*))', 'gi');
+    // Create an array to hold our data. Give the array
+    // a default empty first row.
+    const arrData = [[]];
+    // Create an array to hold our individual pattern
+    // matching groups.
+    let arrMatches = null;
+    // Keep looping over the regular expression matches
+    // until we can no longer find a match.
+    while ((arrMatches = objPattern.exec(strData))) {
+        // Get the delimiter that was found.
+        const strMatchedDelimiter = arrMatches[1];
+        // Check to see if the given delimiter has a length
+        // (is not the start of string) and if it matches
+        // field delimiter. If idKey does not, then we know
+        // that this delimiter is a row delimiter.
+        if (strMatchedDelimiter.length && strMatchedDelimiter !== strDelimiter) {
+            // Since we have reached a new row of data,
+            // add an empty row to our data array.
+            arrData.push([]);
+        }
+        let strMatchedValue;
+        // Now that we have our delimiter out of the way,
+        // let's check to see which kind of value we
+        // captured (quoted or unquoted).
+        if (arrMatches[2]) {
+            // We found a quoted value. When we capture
+            // this value, unescape any double quotes.
+            strMatchedValue = arrMatches[2].replace(new RegExp('""', 'g'), '"');
+        }
+        else {
+            // We found a non-quoted value.
+            strMatchedValue = arrMatches[3];
+        }
+        // Now that we have our value string, let's add
+        // it to the data array.
+        arrData[arrData.length - 1].push(strMatchedValue);
+    }
+    // Return the parsed data.
+    return arrData;
+}
+
+const booleanRegex = /^(true|false)$/i;
+const trueRegex = /^(true)$/i;
+const jsonRegex = /([\d.]+)|(\[])|(\[.+])|({.+})/i;
+const zipObject = (props, values) => props.reduce((obj, prop, index) => ((obj[prop] = values[index]), obj), {});
+const toHead = (input) => {
+    return String(input).trim();
+};
+const toCorrectString = (input) => {
+    if (typeof input === 'string') {
+        if (input.match(jsonRegex)) {
+            // optimization for use try-catch only after regex match. much faster than without regex
+            try {
+                return JSON.parse(input);
+            }
+            catch {
+                /* empty */
+            }
+        }
+        if (input.match(booleanRegex)) {
+            return !!input.match(trueRegex);
+        }
+        return input.trim();
+    }
+    else if (typeof input === 'number') {
+        return input;
+    }
+};
+function CSV2Records(csv, useRowAsHead = 0, strDelimiter) {
+    const arr = CSV2Array(csv, strDelimiter);
+    const total = arr.length;
+    const keys = arr[useRowAsHead].map(toHead);
+    const data = [];
+    let tmpSKU = 0;
+    for (let i = useRowAsHead + 1; i < total; i++) {
+        const obj = zipObject(keys, arr[i].map(toCorrectString));
+        data.push(obj);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        tmpSKU++;
+    }
+    return data.filter(Boolean);
+}
+
+function ObjectToCSV(records) {
+    if (records.length === 0) {
+        return;
+    }
+    const uniqueFields = Array.from(records.reduce((fields, record) => {
+        Object.keys(record).forEach((field) => fields.add(field));
+        return fields;
+    }, new Set()));
+    const csvHeader = uniqueFields.join(',') + '\n';
+    const csvRows = records
+        .map((record) => uniqueFields.map((field) => `"${record[field] || ''}"`).join(','))
+        .join('\n');
+    return csvHeader + csvRows;
+}
+
+const isLocalhost = !!window.location.href.match(/localhost/gi);
+
+/**
+ * Adds required number of symbols before input
+ * @param input input string
+ * @param size amount of total symbols
+ * @param symbol filler
+ * @returns string
+ */
+function pad(input, size, symbol = '0') {
+    let s = input + '';
+    while (s.length < size) {
+        s = symbol + s;
+    }
+    return s.slice(-size);
+}
+
+/**
+ * Create a string of the form 'HOURS.MINUTES.SECONDS.MILLISECONDS'.
+ */
+function timeToString() {
+    const date = new Date();
+    return `${pad(date.getHours(), 2)}:${pad(date.getMinutes(), 2)}:${pad(date.getSeconds(), 2)}.${pad(date.getMilliseconds(), 3)}`;
+}
+function timeUTCToString() {
+    const date = new Date();
+    return `${pad(date.getUTCHours(), 2)}:${pad(date.getUTCMinutes(), 2)}:${pad(date.getUTCSeconds(), 2)}.${pad(date.getUTCMilliseconds(), 3)}`;
+}
+
+/**
+ * The Boolean object represents a truth value: true or false.
+ * @param value
+ * @constructor
+ * Returns:boolean
+ */
+const Truthy = (value) => !!value && value !== 'false' && value !== 'undefined' && value !== 'null';
+/**
+ * The Boolean object represents a INVERSE truth value: true or false.
+ * @param value
+ * @constructor
+ * Returns:boolean
+ */
+const Falsy = (value) => !Truthy(value);
+/**
+ * Checks if a value is empty.
+ *
+ * @param {any} value - The value to check.
+ * @return {boolean} Returns true if the value is empty, otherwise false.
+ */
+const IsEmpty = (value) => {
+    return (value === undefined ||
+        value === null ||
+        (typeof value === 'object' && Object.keys(value).length === 0) ||
+        (typeof value === 'string' && value.trim().length === 0));
+};
+const NotEmpty = (value) => {
+    return !IsEmpty(value);
+};
+
+class Logger {
+    static { this.isDevMode = Truthy(localStorage.getItem('devMode')); }
+    static colored(color, background, ...args) {
+        if (!Logger.isDevMode) {
+            return;
+        }
+        const [first, ...rest] = args;
+        console.log.apply(console, [
+            `%c ${timeUTCToString()} ${first} `,
+            `color: ${color}; background: ${background};`,
+            ...rest,
+        ]);
+    }
+    static log(...args) {
+        if (!Logger.isDevMode) {
+            return;
+        }
+        console.log.apply(console, [
+            `%c ${timeUTCToString()}  [ LOG  ] `,
+            'color: black; background: #80ff80;',
+            ...args,
+        ]);
+    }
+    static warn(...args) {
+        if (!Logger.isDevMode) {
+            return;
+        }
+        console.warn.apply(console, [
+            `%c ${timeUTCToString()} WARN `,
+            'color: black; background: #ffd500;',
+            ...args,
+        ]);
+    }
+    static info(...args) {
+        if (!Logger.isDevMode) {
+            return;
+        }
+        console.log.apply(console, [
+            `%c ${timeUTCToString()}  [ INFO ] `,
+            'color: white; background: blue;',
+            ...args,
+        ]);
+    }
+    static error(...args) {
+        if (!Logger.isDevMode) {
+            return;
+        }
+        console.error.apply(console, [
+            `%c ${timeUTCToString()} ERROR `,
+            'color: white; background: red;',
+            ...args,
+        ]);
+    }
+    static table(...args) {
+        if (!Logger.isDevMode) {
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.table.apply(console, [args]);
+    }
+    static time(...args) {
+        if (!Logger.isDevMode) {
+            return;
+        }
+        // eslint-disable-next-line no-console,prefer-spread
+        console.time.apply(console, args);
+    }
+    static timeEnd(...args) {
+        if (!Logger.isDevMode) {
+            return;
+        }
+        // eslint-disable-next-line no-console,prefer-spread
+        console.timeEnd.apply(console, args);
+    }
+}
+
+function cleanupFileName(value) {
+    if (!value) {
+        return value;
+    }
+    value = value
+        .toString()
+        .replace(/undefined/g, '')
+        .trim()
+        .replace(/\//g, '-')
+        .replace(/[-]+/g, '-')
+        .replace(/[^\w^.-]+/gi, '_')
+        .replace(/[\^]+/gi, '_');
+    value = value.split('_').filter(Boolean).join('_').toLowerCase();
+    return value;
+}
+
+function makePath(...value) {
+    return [...value].map((el) => cleanupFileName(el)).join('/');
+}
+
+function normalizePath(value) {
+    const re = new RegExp('[/\\\\]+', 'g');
+    return value
+        .split(re)
+        .map((el) => cleanupFileName(el))
+        .join('/');
+}
+
+function expandOverRectangle(objectRect, areaRect) {
+    const ratio = objectRect.w / objectRect.h;
+    const result = { x: 0, y: 0, w: 0, h: 0, scale: 1 };
+    if (areaRect.w / ratio < areaRect.h) {
+        result.w = areaRect.h * ratio;
+        result.h = areaRect.h;
+    }
+    else {
+        result.w = areaRect.w;
+        result.h = areaRect.w / ratio;
+    }
+    result.x = areaRect.x + (areaRect.w - result.w) / 2;
+    result.y = areaRect.y + (areaRect.h - result.h) / 2;
+    result.scale = result.w / objectRect.w;
+    return result;
+}
+
+function fitIntoRectangle(objectRect, areaRect, round = true, fixedRatio = null) {
+    const result = { x: 0, y: 0, w: 0, h: 0, scale: 1 };
+    const ratio = objectRect.h / objectRect.w;
+    if (objectRect.h > objectRect.w) {
+        result.h = areaRect.h;
+        result.w = areaRect.h / ratio;
+        if (result.w > areaRect.w) {
+            result.w = areaRect.w;
+            result.h = areaRect.w * ratio;
+        }
+    }
+    else {
+        result.w = areaRect.w;
+        result.h = areaRect.w * ratio;
+        if (result.h > areaRect.h) {
+            result.h = areaRect.h;
+            result.w = areaRect.h / ratio;
+        }
+    }
+    if (fixedRatio) {
+        result.w = objectRect.w * fixedRatio;
+        result.h = objectRect.h * fixedRatio;
+    }
+    const wOut = round ? Math.floor(result.w) : result.w;
+    const hOut = round ? Math.floor(result.h) : result.h;
+    return {
+        x: areaRect.x + (areaRect.w - wOut) / 2,
+        y: areaRect.y + (areaRect.h - hOut) / 2,
+        w: wOut,
+        h: hOut,
+        scale: wOut / objectRect.w,
+    };
+}
+
+const canvasCacheObj = {};
+function getCanvasCached(id) {
+    if (!canvasCacheObj[id]) {
+        const canvas = document.createElement('canvas');
+        canvasCacheObj[id] = {
+            canvas,
+            ctx: canvas.getContext('2d'),
+        };
+    }
+    return canvasCacheObj[id];
+}
+
+function getSnapshot2(imageElement, maxWidth = 1024, output = 'image/png', quality = 0.9) {
+    const drawableImage = imageElement;
+    const canvasHelper = document.createElement('canvas');
+    const drawCTX = canvasHelper.getContext('2d');
+    const prop = fitIntoRectangle({
+        x: 0,
+        y: 0,
+        w: drawableImage.naturalWidth || drawableImage.width,
+        h: drawableImage.naturalHeight || drawableImage.height,
+    }, {
+        x: 0,
+        y: 0,
+        w: maxWidth,
+        h: drawableImage.naturalHeight || drawableImage.height,
+    });
+    const width = prop.w;
+    const height = prop.h;
+    canvasHelper.width = width;
+    canvasHelper.height = height;
+    drawCTX.save();
+    drawCTX.clearRect(0, 0, width, height);
+    drawCTX.drawImage(drawableImage, 0, 0, width, height);
+    drawCTX.restore();
+    if (output === 'canvas') {
+        return canvasHelper;
+    }
+    return canvasHelper.toDataURL(output, quality);
+}
+function getSnapshot(imageElement, maxWidth = 1024, output = 'image/png', quality = 0.9) {
+    const drawableImage = imageElement;
+    const canvasHelper = document.createElement('canvas');
+    const drawCTX = canvasHelper.getContext('2d');
+    const prop = fitIntoRectangle({
+        x: 0,
+        y: 0,
+        w: drawableImage.naturalWidth || drawableImage.width,
+        h: drawableImage.naturalHeight || drawableImage.height,
+    }, {
+        x: 0,
+        y: 0,
+        w: (drawableImage.naturalWidth || drawableImage.width) / 2,
+        h: drawableImage.naturalHeight || drawableImage.height,
+    });
+    const width = prop.w;
+    const height = prop.h;
+    canvasHelper.width = width;
+    canvasHelper.height = height;
+    drawCTX.save();
+    drawCTX.clearRect(0, 0, width, height);
+    drawCTX.drawImage(drawableImage, 0, 0, width, height);
+    drawCTX.restore();
+    if (width > maxWidth * 2) {
+        return getSnapshot(canvasHelper, maxWidth, output, quality);
+    }
+    return getSnapshot2(drawableImage, maxWidth, output, quality);
+}
+
+function loadImage(url) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.crossOrigin = 'anonymous';
+        img.onload = () => {
+            setTimeout(() => resolve(img), 1);
+        };
+        img.onerror = () => {
+            setTimeout(() => reject(null), 1);
+        };
+        img.src = url;
+    });
+}
+
+/**
+ * USE DownloadImage instead!
+ * @deprecated use DownloadImage instead!
+ * @param imageSource
+ * @param name
+ * @param width
+ * @param format
+ */
+function SaveImage(imageSource, name, width, format) {
+    let out;
+    const image = imageSource;
+    if (typeof image !== 'string') {
+        out = getSnapshot(image, width, format);
+    }
+    else {
+        out = image;
+    }
+    if (navigator.msSaveBlob) {
+        // IE10+
+        try {
+            const blob = image.msToBlob();
+            return navigator.msSaveBlob(blob, name);
+        }
+        catch (e) {
+            console.warn(e);
+        }
+    }
+    else {
+        const uri = out;
+        const link = document.createElement('a');
+        link.download = name;
+        link.href = uri;
+        document.body.appendChild(link);
+        if (link.click) {
+            link.click();
+        }
+        else {
+            const event = document.createEvent('MouseEvents');
+            event.initMouseEvent('click', true, true, window);
+            link.dispatchEvent(event);
+        }
+        document.body.removeChild(link);
+    }
+}
+/**
+ * @param imageSource
+ * @param string name
+ * @param number width
+ * @param string format
+ */
+const DownloadImage = SaveImage;
+
+class BatchLoader {
+    constructor() {
+        this.maximumSlotsNumber = 1;
+        this.queue = [];
+        this.slots = [];
+    }
+    clear() {
+        this.queue.forEach((item) => {
+            try {
+                if (item.img) {
+                    item.img.src = '';
+                }
+            }
+            catch (e) {
+                console.warn(e);
+            }
+            try {
+                item.xhr?.abort();
+            }
+            catch (e) {
+                console.warn(e);
+            }
+        });
+        this.slots.forEach((item) => {
+            try {
+                if (item.img) {
+                    item.img.src = '';
+                }
+            }
+            catch (e) {
+                console.warn(e);
+            }
+            try {
+                item.xhr?.abort();
+            }
+            catch (e) {
+                console.warn(e);
+            }
+        });
+        this.slots.length = 0;
+        this.queue.length = 0;
+    }
+    /**
+     * new settings
+     * you must pass new settings
+     * @param sett
+     */
+    setSettings(sett) {
+        this.maximumSlotsNumber =
+            sett.maximumSlotsNumber !== undefined
+                ? sett.maximumSlotsNumber
+                : this.maximumSlotsNumber;
+    }
+    /**
+     * execute with a chosen file
+     * @param id
+     * @param func
+     */
+    withItem(id, func) {
+        let item = this.getById(id);
+        if (!item) {
+            return false;
+        }
+        item = func(item);
+        this.queue.sort(this.sortByOrder);
+        return true;
+    }
+    remove(id) {
+        this.queue = this.queue.filter((arg) => arg.id !== id);
+        return this.queue;
+    }
+    /**
+     * executes when all files are downloaded
+     * @param cb
+     */
+    whenDone(cb) {
+        this._whenDone = cb;
+    }
+    // order {number} lower will execute first, default *100*
+    load(args) {
+        const out = args
+            .filter((arg) => !!arg.path)
+            .map((arg) => ({
+            path: arg.path,
+            id: this.add(arg),
+        }));
+        this.queue.sort(this.sortByOrder);
+        this.checkSlots();
+        return out;
+    }
+    /**
+     * operates with one file
+     * @param item
+     * @private
+     */
+    add(item) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const that = this;
+        const temp = {
+            id: item.id,
+            resolutionId: null,
+            useXhr: item.useXhr,
+            order: item.order !== undefined ? item.order : 100,
+            fallBack: item.fallBack,
+            path: item.path,
+            onLoadEnd: item.onLoadEnd,
+            onProgress: item.onProgress,
+            onLoadStart: item.onLoadStart,
+            extra: item.extra,
+        };
+        let retryCount = 1;
+        if (temp.useXhr) {
+            temp.xhr = this.getXmlHttp();
+            temp.xhr.onloadstart = (data) => item.onLoadStart(data);
+            temp.xhr.onprogress = (data) => item.onProgress(data);
+            temp.xhr.onreadystatechange = async function (data) {
+                if (this.readyState === 1 && this.status === 0) {
+                    return;
+                }
+                if (this.readyState === 4 &&
+                    (this.status === 404 || this.status === 0)) {
+                    temp.error = true;
+                    that.loadEnd(temp);
+                    return;
+                }
+                if (this.readyState === 4 && this.status === 200) {
+                    const urlCreator = window.URL;
+                    const imageUrl = urlCreator.createObjectURL(data.target.response);
+                    temp.img = await loadImage(imageUrl);
+                    that.loadEnd(temp);
+                    return;
+                }
+            };
+        }
+        else {
+            temp.img = new Image();
+            temp.img.crossOrigin = 'anonymous';
+            temp.img.onload = () => {
+                that.loadEnd(temp);
+            };
+            temp.img.onerror = () => {
+                if (temp.fallBack && retryCount-- > 0) {
+                    console.warn('Fallback used =>', temp.path, '=>', temp.fallBack);
+                    if (temp.img) {
+                        temp.img.onload = null;
+                        temp.img.src = temp.fallBack;
+                    }
+                    that.loadEnd(temp);
+                }
+                else {
+                    temp.error = true;
+                    that.loadEnd(temp);
+                }
+            };
+        }
+        this.queue.push(temp);
+        return temp.id;
+    }
+    sortByOrder(a, b) {
+        return a.order > b.order ? 1 : a.order < b.order ? -1 : 0;
+    }
+    loadEnd(item) {
+        if (item.onLoadEnd !== undefined) {
+            for (let i = 0, len = this.slots.length; i < len; i += 1) {
+                if (this.slots[i].id === item.id) {
+                    this.slots.splice(i, 1);
+                    break;
+                }
+            }
+            item.onLoadEnd(item);
+        }
+        this.checkSlots();
+    }
+    checkSlots() {
+        while ((this.slots.length < this.maximumSlotsNumber ||
+            this.maximumSlotsNumber === -1) &&
+            this.queue.length) {
+            this.slots.push(this.queue.shift());
+            const slot = this.slots[this.slots.length - 1];
+            if (slot.useXhr) {
+                slot.xhr?.open('GET', slot.path, true);
+                slot.xhr?.send(null);
+            }
+            else {
+                if (slot.img) {
+                    slot.img.src = slot.path;
+                }
+            }
+        }
+        if (this.slots.length === 0 &&
+            this.queue.length === 0 &&
+            this._whenDone !== undefined) {
+            this._whenDone();
+        }
+    }
+    /**
+     * get Item By id for interaction with files in this.queue
+     * @param id
+     * @private
+     */
+    getById(id) {
+        for (let i = 0, len = this.queue.length; i < len; i += 1) {
+            if (this.queue[i].id === id) {
+                return this.queue[i];
+            }
+        }
+        return null;
+    }
+    getXmlHttp() {
+        let xhr = null;
+        try {
+            xhr = new XMLHttpRequest();
+            xhr.responseType = 'blob';
+        }
+        catch (e) {
+            console.warn(e);
+        }
+        return xhr;
+    }
+}
+
+const KeyboardNumericCode = {
+    Backspace: 8,
+    Tab: 9,
+    Numpad5: 12,
+    NumpadEnter: 13,
+    ShiftRight: 16,
+    ControlRight: 17,
+    ControlLeft: 17,
+    AltRight: 18,
+    Escape: 27,
+    Space: 32,
+    Numpad9: 33,
+    Numpad3: 34,
+    Numpad1: 35,
+    Numpad7: 36,
+    Numpad4: 37,
+    Numpad8: 38,
+    Numpad6: 39,
+    Numpad2: 40,
+    Numpad0: 45,
+    NumpadDecimal: 46,
+    Digit0: 48,
+    Digit1: 49,
+    Digit2: 50,
+    Digit3: 51,
+    Digit4: 52,
+    Digit5: 53,
+    Digit6: 54,
+    Digit7: 55,
+    Digit8: 56,
+    Digit9: 57,
+    KeyA: 65,
+    KeyB: 66,
+    KeyC: 67,
+    KeyD: 68,
+    KeyE: 69,
+    KeyF: 70,
+    KeyG: 71,
+    KeyH: 72,
+    KeyI: 73,
+    KeyJ: 74,
+    KeyK: 75,
+    KeyL: 76,
+    KeyM: 77,
+    KeyN: 78,
+    KeyO: 79,
+    KeyP: 80,
+    KeyQ: 81,
+    KeyR: 82,
+    KeyS: 83,
+    KeyT: 84,
+    KeyU: 85,
+    KeyV: 86,
+    KeyW: 87,
+    KeyX: 88,
+    KeyY: 89,
+    KeyZ: 90,
+    MetaLeft: 91,
+    ContextMenu: 93,
+    NumpadMultiply: 106,
+    NumpadAdd: 107,
+    NumpadSubtract: 109,
+    NumpadDivide: 111,
+    F1: 112,
+    F2: 113,
+    F3: 114,
+    F4: 115,
+    F5: 116,
+    F6: 117,
+    F7: 118,
+    F8: 119,
+    F9: 120,
+    F10: 121,
+    F11: 122,
+    F12: 123,
+    NumLock: 144,
+    ScrollLock: 145,
+    Semicolon: 186,
+    Equal: 187,
+    Comma: 188,
+    Minus: 189,
+    Period: 190,
+    Slash: 191,
+    Backquote: 192,
+    BracketLeft: 219,
+    Backslash: 220,
+    BracketRight: 221,
+    Quote: 222,
+    IntlBackslash: 226,
+    ArrowUp: 38,
+    ArrowDown: 40,
+    ArrowLeft: 37,
+    ArrowRight: 39,
+};
+const InvertedKeyMapValues = {};
+//For use for InvertedKeyMap[32] will return 'Space' and so on
+const InvertedKeyMap = InvertedKeyMapValues;
+const KeyboardStringCode = {};
+Object.entries(KeyboardNumericCode).forEach(
+// @ts-expect-error @typescript-eslint/ban-ts-comment
+([key, value]) => {
+    InvertedKeyMapValues[value] = key;
+    // @ts-expect-error @typescript-eslint/ban-ts-comment
+    KeyboardStringCode[key] = key;
+});
+
+function serialize(obj) {
+    const str = [];
+    for (const p in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, p)) {
+            str.push(encodeURIComponent(p) + '=' + encodeURIComponent(obj[p]));
+        }
+    }
+    return str.join('&');
+}
+
+function sleep(time) {
+    return new Promise((r) => setTimeout(r, time));
+}
+
+function trimLastSlashFromUrl(baseUrl) {
+    if (!baseUrl) {
+        return null;
+    }
+    else if (baseUrl[baseUrl.length - 1] === '/') {
+        return baseUrl.substring(0, baseUrl.length - 1);
+    }
+    return;
+}
+
+const ImageOutput = {
+    CANVAS: 'canvas',
+    PNG: 'image/png',
+    WEBP: 'image/webp',
+    JPG: 'image/jpeg',
+};
+
+/**
+ * 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);
+ */
+function baseSortedIndex(array, value) {
+    const MAX_ARRAY_LENGTH = 4294967295;
+    const HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
+    let low = 0;
+    let high = array?.length || low;
+    if (high <= HALF_MAX_ARRAY_LENGTH) {
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            const computed = array[mid];
+            if (computed !== null && computed < value) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+    }
+    return high;
+}
+
+/**
+ * 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
+ * ```
+ */
+function calculateMedian(numbers) {
+    if (numbers.length === 0)
+        return 0;
+    // Sort the array in ascending order
+    const sorted = [...numbers].sort((a, b) => a - b);
+    const length = sorted.length;
+    const middle = Math.floor(length / 2);
+    // If the length is even, return the average of the two middle numbers
+    if (length % 2 === 0) {
+        return (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+    // If the length is odd, return the middle number
+    return sorted[middle];
+}
+
+/**
+ * Clamps value between min and max;
+ * @param min minValue
+ * @param max maxValue
+ * @param value inputValue
+ * @returns number
+ */
+function clampf(min, max, value) {
+    if (min > max) {
+        return min;
+    }
+    return Math.min(max, Math.max(min, value));
+}
+
+/**
+ * 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
+ */
+function circularIndex(index, totalItems) {
+    return clampf(0, totalItems - 1, (totalItems * 2 + index) % totalItems);
+}
+
+function degreesToRadians(degrees) {
+    return degrees * (Math.PI / 180);
+}
+function radiansToDegrees(radians) {
+    return radians * (180 / Math.PI);
+}
+
+/**
+ * A small epsilon value used for floating-point comparisons.
+ *
+ * @remarks
+ * The value of `EPSILON` is `0.01`. This can be overridden in the comparison functions if needed.
+ */
+const EPSILON = 0.01;
+/**
+ * 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
+ * ```
+ */
+function fpIsALessThanB(A, B, Epsilon) {
+    Epsilon = Epsilon || EPSILON;
+    return A - B < Epsilon && Math.abs(A - B) > Epsilon;
+}
+/**
+ * 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
+ * ```
+ */
+function fpIsAGreaterThanB(A, B, Epsilon) {
+    Epsilon = Epsilon || EPSILON;
+    return A - B > Epsilon && Math.abs(A - B) > Epsilon;
+}
+/**
+ * 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
+ * ```
+ */
+function fpIsASameAsB(A, B, Epsilon) {
+    Epsilon = Epsilon || EPSILON;
+    return Math.abs(A - B) < Epsilon;
+}
+
+/**
+ * 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.
+ */
+function inverseLerp(min, max, value, clampToNormal = false) {
+    if (clampToNormal) {
+        value = Math.min(max, value);
+        value = Math.max(min, value);
+    }
+    const difference = max - min;
+    // Avoid JS division error
+    if (difference === 0) {
+        return 1;
+    }
+    const result = (value - min) / difference;
+    if (clampToNormal) {
+        return Math.min(1, Math.max(0, result));
+    }
+    return result;
+}
+
+/**
+ * @param min minimums
+ * @param max maximums
+ * @param value current float value in 0-1 range
+ * @returns clamped value
+ */
+function lerp(min, max, value) {
+    value = clampf(0, 1, value);
+    return value * (max - min) + min;
+}
+
+/**
+ * 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"
+ */
+class Mutex {
+    constructor() {
+        this.mutex = Promise.resolve();
+    }
+    /**
+     * 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.
+     */
+    async acquire() {
+        let release;
+        const previous = this.mutex;
+        this.mutex = new Promise((resolve) => (release = resolve));
+        await previous;
+        return release;
+    }
+}
+
+/**
+ * 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"
+ */
+class Semaphore {
+    constructor(maxConcurrency) {
+        this.maxConcurrency = maxConcurrency;
+        this.tasks = [];
+        this.currentCount = 0;
+    }
+    acquire() {
+        return new Promise((resolve) => {
+            if (this.currentCount < this.maxConcurrency) {
+                this.currentCount++;
+                resolve();
+            }
+            else {
+                this.tasks.push(resolve);
+            }
+        });
+    }
+    release() {
+        if (this.tasks.length > 0) {
+            const nextTask = this.tasks.shift();
+            if (nextTask) {
+                nextTask();
+            }
+        }
+        else if (this.currentCount > 0) {
+            this.currentCount--;
+        }
+    }
+}
+
+class TaskRunner {
+    constructor() {
+        this.mutex = new Mutex();
+    }
+    runTask(name, task) {
+        // Log that the task is waiting to acquire the mutex
+        Logger.log(`${name} waiting to acquire mutex`);
+        return from(this.mutex.acquire()).pipe(switchMap((release) => {
+            // Log that the mutex has been acquired
+            Logger.log(`${name} acquired mutex`);
+            return task().pipe(finalize(() => {
+                Logger.log(`${name} releasing mutex`);
+                release();
+            }));
+        }));
+    }
+}
+
+const cache = {};
+/**
+ * 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.
+ *
+ */
+function textForSearch(value, caseSensitive = false) {
+    const key = `${value}_${caseSensitive}`;
+    return (cache[key] ||
+        (() => {
+            let result = String(value).trim().replace(/ +/gi, '_');
+            if (!caseSensitive) {
+                result = result.toLowerCase();
+            }
+            cache[key] = result;
+            return result;
+        })());
+}
+
+/**
+ * Creates a predicate function to filter records from a collection based on specified criteria.
+ *
+ * The `where` function accepts a criteria object with key-value pairs, indicating the fields
+ * and their expected values for filtering. It returns a predicate function that filters a collection
+ * of records. This predicate checks if records match the criteria using a case-insensitive comparison,
+ * making it particularly useful in conjunction with the `textForSearch` function, which standardizes
+ * strings for such comparisons.
+ *
+ * Each criterion value is first processed with `textForSearch` to normalize spacing and case,
+ * ensuring consistent and predictable filtering. The comparison between each record's field value
+ * and the criterion value is thus case-insensitive and ignores extra spaces.
+ *
+ * @param {Partial<Record<K, T[K]>>} criteria - An object representing the filtering criteria.
+ * Keys correspond to the record's fields to be filtered, and values are the expected values for those fields,
+ * processed in a case-insensitive manner. Undefined values are ignored.
+ *
+ * @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 {(record: T) => boolean} A predicate function that takes a record of type `T`
+ * and returns `true` if the record's field values match all criteria, otherwise `false`.
+ *
+ * @example
+ * // Define a collection of items
+ * const items = [
+ *   { name: "Apple", category: "Fruit" },
+ *   { name: "Carrot", category: "Vegetable" },
+ *   { name: "Banana", category: "Fruit" }
+ * ];
+ *
+ * // Create a predicate to find fruits, using a case-insensitive comparison
+ * const isFruit = where({ category: "fruit" }); // 'fruit' will match 'Fruit' in items
+ *
+ * // Filter the collection with the predicate
+ * const fruits = items.filter(isFruit);
+ * // Output: [{ name: "Apple", category: "Fruit" }, { name: "Banana", category: "Fruit" }]
+ *
+ * @typeparam T - Specifies the type of records in the collection to be filtered. It extends `object`,
+ * ensuring the function is only used with object types. This generic approach allows for flexible usage
+ * with various record structures.
+ */
+function where(criteria, caseSensitive = false) {
+    const preComputedEntries = Object.entries(criteria)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => [key, textForSearch(value, caseSensitive)]);
+    return (record) => {
+        return (preComputedEntries.length > 0 &&
+            preComputedEntries.every(([key, criterionValue]) => {
+                return (textForSearch(record[key] ?? '', caseSensitive) ===
+                    criterionValue);
+            }));
+    };
+}
+function whereNot(criteria, caseSensitive = false) {
+    const whereFunc = where(criteria, caseSensitive);
+    return (record) => {
+        return !whereFunc(record);
+    };
+}
+
+/**
+ * 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.
+ */
+function leadingTrailingDebounceTime(dueTime, scheduler = asyncScheduler) {
+    return (source) => new Observable((subscriber) => {
+        let hasValue = false;
+        let lastValue = null;
+        let timerSubscription = null;
+        let leading = true; // Controls whether we emit immediately.
+        const clearTimer = () => {
+            if (timerSubscription) {
+                timerSubscription.unsubscribe();
+                timerSubscription = null;
+            }
+        };
+        const resetValues = () => {
+            hasValue = false;
+            lastValue = null;
+            leading = true; // Reset so the next new value is immediate.
+        };
+        const emitLastValue = () => {
+            if (hasValue && lastValue !== null) {
+                subscriber.next(lastValue);
+                resetValues();
+            }
+        };
+        const sourceSubscription = source.subscribe({
+            next: (value) => {
+                // If we are "leading", emit immediately and switch leading off
+                if (leading) {
+                    subscriber.next(value);
+                    leading = false;
+                    timerSubscription = timer(dueTime, scheduler).subscribe(() => {
+                        resetValues();
+                        clearTimer();
+                    });
+                    return;
+                }
+                // Otherwise, save the value and start (or restart) timer
+                hasValue = true;
+                lastValue = value;
+                clearTimer();
+                timerSubscription = timer(dueTime, scheduler).subscribe(() => {
+                    emitLastValue();
+                });
+            },
+            error: (err) => {
+                clearTimer();
+                subscriber.error(err);
+            },
+            complete: () => {
+                // If there is a pending emission, emit it before completing
+                clearTimer();
+                emitLastValue();
+                subscriber.complete();
+            },
+        });
+        // Cleanup logic
+        return () => {
+            clearTimer();
+            sourceSubscription.unsubscribe();
+        };
+    });
+}
+
+/**
+ * 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.
+ */
+const smoothTransition = (start, end, duration) => {
+    const startTime = animationFrameScheduler.now();
+    return interval(0, animationFrameScheduler).pipe(map(() => {
+        const elapsed = (animationFrameScheduler.now() - startTime) / duration;
+        return clampf(0, 1, elapsed);
+    }), distinctUntilChanged(), map((fraction) => lerp(start, end, fraction)));
+};
+
+const tapLog = (text, ...args) => (source) => source.pipe(tap((data) => {
+    Logger.colored(...COLOR_CODES.TAP_LOG, text, data, ...args);
+}));
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BatchLoader, CMYKtoRGB, COLOR_CODES, CSV2Array, CSV2Records, DownloadImage, Falsy, HEXtoRGB, HSVtoRGB, ImageOutput, InvertedKeyMap, IsEmpty, KeyboardNumericCode, KeyboardStringCode, Logger, Mutex, NotEmpty, ObjectToCSV, RGBtoCMYK, RGBtoHEX, RGBtoHSV, SaveImage, Semaphore, TaskRunner, Truthy, baseSortedIndex, calculateMedian, circularIndex, clampf, cleanupFileName, degreesToRadians, expandOverRectangle, fitIntoRectangle, fpIsAGreaterThanB, fpIsALessThanB, fpIsASameAsB, getCanvasCached, getSnapshot, hsv, inverseLerp, isLocalhost, leadingTrailingDebounceTime, lerp, loadImage, makePath, max, min, normalizePath, overlay, pad, radiansToDegrees, rgb, serialize, sleep, smoothTransition, sub, subtract, sum, tapLog, textForSearch, timeToString, timeUTCToString, toRGB, toRGBA, trimLastSlashFromUrl, where, whereNot };
+//# sourceMappingURL=3dsource-utils.mjs.map