@stemy/backend 5.2.2 → 6.0.0

package/esm2022/utils.mjs

@@ -0,0 +1,726 @@
+import { mkdir, readFile as fsReadFile, unlink, writeFile as fsWriteFile } from "fs";
+import { gzip, gunzip } from "zlib";
+import { basename, dirname } from "path";
+import { fileURLToPath } from "url";
+import { exec as execChildProcess } from "child_process";
+import { createHash } from "crypto";
+import { from, Observable, Subject, Subscription } from "rxjs";
+import { ObjectId } from "mongodb";
+import mongoose from "mongoose";
+import { PassThrough, Readable } from "stream";
+import sharp_ from "sharp";
+import { HttpError } from "routing-controllers";
+import axios from "axios";
+import { fileTypeFromStream as ftFromStream, fileTypeFromBuffer as ftFromBuffer } from "file-type/core";
+const sharp = sharp_;
+export const diContainers = {
+    appContainer: null
+};
+export function isNullOrUndefined(value) {
+    return value == null || typeof value == "undefined";
+}
+export function isDefined(value) {
+    return !isNullOrUndefined(value);
+}
+export function getType(obj) {
+    const regex = new RegExp("\\s([a-zA-Z]+)");
+    return Object.prototype.toString.call(obj).match(regex)[1].toLowerCase();
+}
+export function isObject(value) {
+    return getType(value) == "object";
+}
+export function isArray(value) {
+    return Array.isArray(value);
+}
+export function isBuffer(value) {
+    return value instanceof Buffer;
+}
+export function isBoolean(value) {
+    return typeof value === "boolean";
+}
+export function isDate(value) {
+    return !!value && value[Symbol.toPrimitive] && !isNaN(value) && "undefined" !== typeof value.getDate;
+}
+export function isPrimitive(value) {
+    const type = typeof value;
+    return value == null || (type !== "object" && type !== "function");
+}
+export function isString(value) {
+    return typeof value === "string";
+}
+export function isFunction(value) {
+    return typeof value === "function";
+}
+export function isConstructor(value) {
+    return (value && typeof value === "function" && value.prototype && value.prototype.constructor) === value && value.name !== "Object";
+}
+export function isType(value) {
+    return isConstructor(value);
+}
+export function isInterface(obj, interFaceObject) {
+    if (!obj || typeof obj !== "object" || isArray(obj) || !isObject(interFaceObject))
+        return false;
+    const keys = Object.keys(interFaceObject);
+    for (const key of keys) {
+        let type = interFaceObject[key] || "";
+        if (type.startsWith("*")) {
+            type = type.substr(1);
+            if (obj.hasOwnProperty(key) && getType(obj[key]) !== type)
+                return false;
+        }
+        else if (!obj.hasOwnProperty(key) || getType(obj[key]) !== type) {
+            return false;
+        }
+    }
+    return true;
+}
+export function ucFirst(value) {
+    if (!value)
+        return "";
+    return value[0].toUpperCase() + value.substr(1);
+}
+export function lcFirst(value) {
+    if (!value)
+        return "";
+    return value[0].toLowerCase() + value.substr(1);
+}
+export function isObjectId(id) {
+    return typeof id === "string" && id.length == 24 && !isNaN(Number("0x" + id));
+}
+export function firstItem(value) {
+    return value[0];
+}
+export function lastItem(value) {
+    return value[value.length - 1];
+}
+export function regroup(value, comparator) {
+    const result = [];
+    if (!isArray(value) || value.length == 0)
+        return result;
+    value = Array.from(value);
+    result.push([value.shift()]);
+    value.forEach(item => {
+        const group = result.find(g => g.some(a => comparator(a, item)));
+        if (group) {
+            group.push(item);
+            return;
+        }
+        result.push([item]);
+    });
+    return result;
+}
+export function uniqueItems(value) {
+    return value.filter((v, ix) => value.indexOf(v) === ix);
+}
+export function getValue(obj, key, defaultValue, treeFallback = false) {
+    key = key || "";
+    const keys = key.split(".");
+    let curKey = "";
+    do {
+        curKey += keys.shift();
+        if (isDefined(obj) && isDefined(obj[curKey]) && (typeof obj[curKey] === "object" || !keys.length)) {
+            obj = obj[curKey];
+            curKey = "";
+        }
+        else if (!keys.length) {
+            defaultValue = typeof defaultValue == "undefined" ? key.replace(new RegExp(`${curKey}$`), `{${curKey}}`) : defaultValue;
+            obj = treeFallback ? obj || defaultValue : defaultValue;
+        }
+        else {
+            curKey += ".";
+        }
+    } while (keys.length);
+    return obj;
+}
+export function groupBy(items, cb) {
+    return items.reduce((res, item) => {
+        const group = cb(item);
+        res[group] = res[group] || [];
+        res[group].push(item);
+        return res;
+    }, {});
+}
+export function convertValue(value, type) {
+    switch (type) {
+        case "boolean":
+            value = typeof value == "string" ? value.toLowerCase() : value;
+            return (value == "no" || value == "false" || value == "0") ? false : !!value;
+        case "number":
+            const val = parseFloat(value);
+            return isNaN(val) ? 0 : val;
+        case "array":
+            try {
+                return JSON.parse(value);
+            }
+            catch (e) {
+                return `${value}`.split(", ");
+            }
+    }
+    return value;
+}
+const cropInterface = {
+    x: "number",
+    y: "number",
+    w: "number",
+    h: "number"
+};
+function toCropRegion(cropInfo) {
+    let crop = cropInfo;
+    if (isString(cropInfo)) {
+        try {
+            crop = JSON.parse(cropInfo);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    if (!isInterface(crop, cropInterface))
+        return null;
+    return {
+        width: Math.round(crop.w),
+        height: Math.round(crop.h),
+        top: Math.round(crop.y),
+        left: Math.round(crop.x)
+    };
+}
+export async function toImage(src, params, meta) {
+    // Default params and meta
+    params = params || {};
+    meta = meta || {};
+    // Get default crop info
+    const crop = toCropRegion(meta.crop);
+    // Return the src if there are no params and no default crop exists
+    if (meta.extension === "svg" || (Object.keys(params).length == 0 && !crop)) {
+        return src;
+    }
+    // Parse params
+    params.rotation = isNaN(params.rotation) ? 0 : Math.round(params.rotation / 90) * 90;
+    params.canvasScaleX = isNaN(params.canvasScaleX) ? 1 : Number(params.canvasScaleX);
+    params.canvasScaleY = isNaN(params.canvasScaleY) ? 1 : Number(params.canvasScaleY);
+    params.scaleX = isNaN(params.scaleX) ? 1 : Number(params.scaleX);
+    params.scaleY = isNaN(params.scaleY) ? 1 : Number(params.scaleY);
+    params.crop = isBoolean(params.crop) ? params.crop : params.crop == "true";
+    let buffer = src instanceof Readable ? await streamToBuffer(src) : src;
+    try {
+        // Get crop info
+        const cropBefore = toCropRegion(params.cropBefore || (params.crop ? meta.cropBefore : null));
+        const cropAfter = toCropRegion(params.cropAfter || (params.crop ? meta.cropAfter : null));
+        // Get metadata
+        let img = sharp(buffer);
+        let { width, height } = await img.metadata();
+        // Crop before resize
+        if (cropBefore) {
+            width = cropBefore.width;
+            height = cropBefore.height;
+            img = img.extract(cropBefore);
+        }
+        else if (crop) {
+            width = crop.width;
+            height = crop.height;
+            img = img.extract(crop);
+        }
+        // Resize canvas
+        const canvasScaleX = meta?.canvasScaleX || 1;
+        const canvasScaleY = meta?.canvasScaleY || 1;
+        if (params.canvasScaleX !== canvasScaleX || params.canvasScaleY !== canvasScaleY) {
+            width = Math.round(width * params.canvasScaleX);
+            height = Math.round(height * params.canvasScaleY);
+            img = img.resize({ width, height, background: "#00000000", fit: "contain" });
+        }
+        // Resize image
+        if (params.scaleX !== 1 || params.scaleY !== 1) {
+            width = Math.round(width * params.scaleX);
+            height = Math.round(height * params.scaleY);
+            img = img.resize({ width, height, background: "#00000000", fit: "fill" });
+        }
+        // Crop after resize
+        if (cropAfter) {
+            img = img.extract(cropAfter);
+        }
+        // Rotate
+        if (params.rotation !== 0) {
+            buffer = await img.toBuffer();
+            img = sharp(buffer).rotate(params.rotation);
+        }
+        buffer = await img.toBuffer();
+        src = src instanceof Readable ? bufferToStream(buffer) : buffer;
+        return src;
+    }
+    catch (e) {
+        console.log("Image conversion error", e);
+        src = src instanceof Readable ? bufferToStream(buffer) : buffer;
+        return src;
+    }
+}
+export function bufferToStream(buffer) {
+    const readStream = new PassThrough();
+    readStream.end(buffer);
+    return readStream;
+}
+export function streamToBuffer(stream) {
+    return new Promise((resolve, reject) => {
+        const concat = [];
+        stream.on("data", data => {
+            concat.push(data);
+        });
+        stream.on("error", reject);
+        stream.on("end", () => resolve(Buffer.concat(concat)));
+    });
+}
+class ReadableStreamClone extends Readable {
+    constructor(readableStream, opts) {
+        super(opts);
+        readableStream?.on("data", chunk => {
+            this.push(chunk);
+        });
+        readableStream?.on("end", () => {
+            this.push(null);
+        });
+        readableStream?.on("error", err => {
+            this.emit("error", err);
+        });
+    }
+    _read(size) {
+    }
+}
+export function copyStream(stream, opts) {
+    return new ReadableStreamClone(stream, opts);
+}
+export function mkdirRecursive(path, mode = null) {
+    return new Promise((resolve, reject) => {
+        mkdir(path, { mode: mode || 0o777, recursive: true }, err => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+export function deleteFile(path) {
+    return new Promise((resolve, reject) => {
+        unlink(path, err => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+export function readFile(path) {
+    return new Promise((res, rej) => {
+        fsReadFile(path, (err, data) => {
+            if (err) {
+                rej(err);
+                return;
+            }
+            res(data);
+        });
+    });
+}
+export async function readAndDeleteFile(path, timeout = 5000) {
+    const data = await readFile(path);
+    setTimeout(() => {
+        unlink(path, () => {
+        });
+    }, timeout);
+    return data;
+}
+export async function writeFile(path, data) {
+    await mkdirRecursive(dirname(path));
+    return new Promise((res, rej) => {
+        fsWriteFile(path, data, err => {
+            if (err) {
+                rej(err);
+                return;
+            }
+            res(data);
+        });
+    });
+}
+export function valueToPromise(value) {
+    return value instanceof Promise ? value : Promise.resolve(value);
+}
+export function promiseTimeout(timeout = 1000, error = false) {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            if (error) {
+                reject(`Timeout exceeded: ${timeout}ms`);
+                return;
+            }
+            resolve(`Timeout: ${timeout}ms`);
+        }, timeout);
+    });
+}
+export function getConstructorName(type) {
+    return type.prototype.constructor.name;
+}
+export function getFunctionParams(func) {
+    // Remove comments of the form /* ... */
+    // Removing comments of the form //
+    // Remove body of the function { ... }
+    // removing "=>" if func is arrow function
+    const str = func.toString()
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/\/\/(.)*/g, "")
+        .replace(/{[\s\S]*}/, "")
+        .replace(/=>/g, "")
+        .trim();
+    // Start parameter names after first "("
+    const start = str.indexOf("(") + 1;
+    // End parameter names is just before last ")"
+    const end = str.length - 1;
+    const result = str.substring(start, end).split(", ");
+    const params = [];
+    result.forEach(element => {
+        // Removing any default value
+        element = element.replace(/=[\s\S]*/g, "").trim();
+        if (element.length > 0)
+            params.push(element);
+    });
+    return params;
+}
+export function getFileName(path, withExtension = false) {
+    const name = basename(path || "");
+    return withExtension ? name : name.split(".").slice(0, -1).join(".");
+}
+export function getExtension(path) {
+    const name = basename(path || "");
+    return name.split(".").pop();
+}
+export function createIdString() {
+    return new ObjectId().toHexString();
+}
+export function idToString(value) {
+    if (Array.isArray(value)) {
+        return value.map(idToString);
+    }
+    return value instanceof ObjectId || value instanceof mongoose.Types.ObjectId
+        ? value.toHexString()
+        : (isString(value) ? value : value || null);
+}
+export function createTransformer(transform) {
+    return (doc, ret, options) => {
+        ret.id = idToString(ret.id) || ret.id;
+        if (doc._id) {
+            ret._id = idToString(doc._id);
+            ret.id = ret.id || ret._id;
+        }
+        delete ret.__v;
+        return isFunction(transform) ? transform(doc, ret, options) || ret : ret;
+    };
+}
+export function broadcast(socketServer, cb) {
+    socketServer.sockets.sockets.forEach((client) => {
+        cb(client);
+    });
+}
+export function rand(min, max) {
+    return Math.round(random(min, max));
+}
+export function random(min, max) {
+    return min + Math.random() * (max - min);
+}
+export function multiSubscription(...subscriptions) {
+    return new Subscription(() => {
+        subscriptions.forEach(s => {
+            s.unsubscribe();
+        });
+    });
+}
+export function observableFromFunction(callbackFunc) {
+    let subject;
+    return new Observable((subscriber) => {
+        if (!subject) {
+            subject = new Subject();
+            try {
+                subject = from(callbackFunc());
+            }
+            catch (err) {
+                subject.error(err);
+            }
+        }
+        return subject.subscribe(subscriber);
+    });
+}
+export function padLeft(value, count = 3, padWith = "0") {
+    return `${value}`.padStart(count, padWith);
+}
+export function padRight(value, count = 3, padWith = "0") {
+    return `${value}`.padEnd(count, padWith);
+}
+export function camelCaseToDash(str) {
+    return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+export function gzipPromised(data, opts) {
+    return new Promise((resolve, reject) => {
+        gzip(data, opts, (err, result) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(result.toString("base64"));
+        });
+    });
+}
+export function gunzipPromised(data, opts) {
+    return new Promise((resolve, reject) => {
+        gunzip(Buffer.from(data, "base64"), opts, (err, result) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(result.toString("utf8"));
+        });
+    });
+}
+export function deleteFromBucket(bucket, id) {
+    const fileId = id instanceof ObjectId ? id : new ObjectId(id);
+    return new Promise(((resolve, reject) => {
+        if (!id) {
+            // We don't care about empty id
+            resolve(null);
+            return;
+        }
+        bucket.delete(fileId, error => {
+            let err = error;
+            if (error) {
+                err = error.message || error || "";
+                if (!isString(err) || !err.startsWith("FileNotFound")) {
+                    reject(err);
+                    return;
+                }
+            }
+            resolve(fileId.toHexString());
+        });
+    }));
+}
+const defaultPredicate = () => true;
+function copyRecursive(target, source, predicate, copies) {
+    if (isPrimitive(source) || isDate(source) || isFunction(source))
+        return source;
+    if (copies.has(source))
+        return copies.get(source);
+    if (isArray(source)) {
+        target = isArray(target) ? Array.from(target) : [];
+        source.forEach((item, index) => {
+            if (!predicate(item, index, target, source))
+                return;
+            if (target.length > index)
+                target[index] = copyRecursive(target[index], item, predicate, copies);
+            else
+                target.push(copyRecursive(null, item, predicate, copies));
+        });
+        copies.set(source, target);
+        return target;
+    }
+    if (isBuffer(source))
+        return Buffer.from(source);
+    // If object defines __shouldCopy as false, then don't copy it
+    if (source.__shouldCopy === false)
+        return source;
+    // Copy object
+    const shouldCopy = isFunction(source.__shouldCopy) ? source.__shouldCopy : () => true;
+    if (isConstructor(source.constructor)) {
+        if (!target) {
+            try {
+                target = new source.constructor();
+            }
+            catch (e) {
+                const proto = source.constructor.prototype || source.prototype;
+                target = Object.create(proto);
+            }
+        }
+    }
+    else {
+        target = Object.assign({}, target || {});
+    }
+    // Set to copies to prevent circular references
+    copies.set(source, target);
+    // Copy map entries
+    if (target instanceof Map) {
+        if (source instanceof Map) {
+            for (let [key, value] of source.entries()) {
+                if (!predicate(value, key, target, source))
+                    continue;
+                target.set(key, !shouldCopy(key, value) ? value : copyRecursive(target.get(key), value, predicate, copies));
+            }
+        }
+        return target;
+    }
+    // Copy object members
+    let keys = Object.keys(source);
+    keys.forEach(key => {
+        if (!predicate(source[key], key, target, source))
+            return;
+        target[key] = !shouldCopy(key, source[key]) ? source[key] : copyRecursive(target[key], source[key], predicate, copies);
+    }, target);
+    // Copy object properties
+    const descriptors = Object.getOwnPropertyDescriptors(source);
+    keys = Object.keys(descriptors).filter(k => keys.indexOf(k) < 0);
+    keys.forEach(key => {
+        Object.defineProperty(target, key, descriptors[key]);
+    });
+    return target;
+}
+export function filter(obj, predicate) {
+    return copyRecursive(null, obj, predicate || defaultPredicate, new Map());
+}
+export function copy(obj) {
+    return copyRecursive(null, obj, defaultPredicate, new Map());
+}
+export function assign(target, source, predicate) {
+    return copyRecursive(target, source, predicate, new Map());
+}
+export function md5(data) {
+    if (isObject(data)) {
+        data = JSON.stringify(data);
+    }
+    if (!isString(data)) {
+        throw `Can't md5 other that raw object or string`;
+    }
+    return createHash("md5").update(data).digest("hex");
+}
+export function runCommand(scriptPath, expectedCode = 0) {
+    return new Promise((resolve, reject) => {
+        const cp = execChildProcess(scriptPath, (error, stdout) => {
+            if (error && expectedCode !== error.code) {
+                console.log(error);
+                reject(error);
+                return;
+            }
+            const lines = (stdout || "").split("\n");
+            let line = null;
+            while (!line && lines.length > 0) {
+                line = lines.pop();
+            }
+            resolve(line);
+        });
+        cp.stdout.on("data", function (data) {
+            console.log(data.toString());
+        });
+        cp.stderr.on("data", function (data) {
+            console.error(data.toString());
+        });
+    });
+}
+export var ConsoleColor;
+(function (ConsoleColor) {
+    ConsoleColor["Reset"] = "\u001B[0m";
+    ConsoleColor["Bright"] = "\u001B[1m";
+    ConsoleColor["Dim"] = "\u001B[2m";
+    ConsoleColor["Underscore"] = "\u001B[4m";
+    ConsoleColor["Blink"] = "\u001B[5m";
+    ConsoleColor["Reverse"] = "\u001B[7m";
+    ConsoleColor["Hidden"] = "\u001B[8m";
+    ConsoleColor["FgBlack"] = "\u001B[30m";
+    ConsoleColor["FgRed"] = "\u001B[31m";
+    ConsoleColor["FgGreen"] = "\u001B[32m";
+    ConsoleColor["FgYellow"] = "\u001B[33m";
+    ConsoleColor["FgBlue"] = "\u001B[34m";
+    ConsoleColor["FgMagenta"] = "\u001B[35m";
+    ConsoleColor["FgCyan"] = "\u001B[36m";
+    ConsoleColor["FgWhite"] = "\u001B[37m";
+    ConsoleColor["FgDefault"] = "\u001B[38m";
+    ConsoleColor["BgBlack"] = "\u001B[40m";
+    ConsoleColor["BgRed"] = "\u001B[41m";
+    ConsoleColor["BgGreen"] = "\u001B[42m";
+    ConsoleColor["BgYellow"] = "\u001B[43m";
+    ConsoleColor["BgBlue"] = "\u001B[44m";
+    ConsoleColor["BgMagenta"] = "\u001B[45m";
+    ConsoleColor["BgCyan"] = "\u001B[46m";
+    ConsoleColor["BgWhite"] = "\u001B[47m";
+    ConsoleColor["BgDefault"] = "\u001B[48m";
+})(ConsoleColor || (ConsoleColor = {}));
+const defaultColors = {
+    keyColor: ConsoleColor.FgWhite,
+    numberColor: ConsoleColor.FgBlue,
+    stringColor: ConsoleColor.FgYellow,
+    trueColor: ConsoleColor.FgGreen,
+    falseColor: ConsoleColor.FgRed,
+    nullColor: ConsoleColor.BgMagenta
+};
+export function colorize(input, color) {
+    return `${color}${input}${ConsoleColor.Reset}`;
+}
+export function jsonHighlight(input, colorOptions) {
+    const colors = Object.assign({}, defaultColors, colorOptions);
+    const json = (isString(input) ? input : JSON.stringify(input, null, 2)).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>');
+    return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+]?\d+)?)/g, (match) => {
+        let color = colors.numberColor;
+        if (/^"/.test(match)) {
+            if (/:$/.test(match)) {
+                color = colors.keyColor;
+            }
+            else {
+                color = colors.stringColor;
+                match = '"' + match.substr(1, match.length - 2) + '"';
+            }
+        }
+        else {
+            color = /true/.test(match)
+                ? colors.trueColor
+                : /false/.test(match)
+                    ? colors.falseColor
+                    : /null/.test(match)
+                        ? colors.nullColor
+                        : color;
+        }
+        return `${color}${match}${ConsoleColor.Reset}`;
+    });
+}
+export function replaceSpecialChars(str, to = "-") {
+    return `${str}`.replace(/[&\/\\#, +()$~%.@'":*?<>{}]/g, to);
+}
+export function regexEscape(str) {
+    return `${str}`.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+export function flatten(arr) {
+    return arr.reduce((flat, toFlatten) => {
+        return flat.concat(isArray(toFlatten) ? flatten(toFlatten) : toFlatten);
+    }, []);
+}
+export function wrapError(e, message, httpCode = 500) {
+    if (axios.isAxiosError(e)) {
+        e.message = message;
+        return e;
+    }
+    return new HttpError(httpCode, `${message}: ${e}`);
+}
+export function getDirName() {
+    if (typeof __dirname === "undefined") {
+        const __filename = fileURLToPath(import.meta.url);
+        return dirname(__filename);
+    }
+    return __dirname;
+}
+export function prepareUrl(ending = "/") {
+    return url => {
+        return url ? `${url.replace(/\/+$/, "")}${ending}` : ending;
+    };
+}
+export const prepareUrlSlash = prepareUrl("/");
+export const prepareUrlEmpty = prepareUrl("");
+function checkTextFileType(type) {
+    return type.mime.indexOf("text") >= 0 || type.mime.indexOf("xml") >= 0;
+}
+function fixTextFileType(type, buffer) {
+    const text = buffer.toString("utf8");
+    if (text.indexOf("<svg") >= 0) {
+        return { ext: "svg", mime: "image/svg+xml" };
+    }
+    return type;
+}
+export async function fileTypeFromBuffer(buffer) {
+    const stream = bufferToStream(buffer);
+    const type = (await ftFromBuffer(buffer) ?? { ext: "txt", mime: "text/plain" });
+    if (checkTextFileType(type)) {
+        return fixTextFileType(type, buffer);
+    }
+    return type;
+}
+export async function fileTypeFromStream(stream) {
+    return (await ftFromStream(stream) ?? { ext: "txt", mime: "text/plain" });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {mkdir, readFile as fsReadFile, unlink, writeFile as fsWriteFile} from \"fs\";\nimport {gzip, gunzip, ZlibOptions} from \"zlib\";\nimport {basename, dirname} from \"path\";\nimport {fileURLToPath} from \"url\";\nimport {exec as execChildProcess} from \"child_process\";\nimport {createHash} from \"crypto\";\nimport {from, Observable, Subject, Subscription} from \"rxjs\";\nimport {Server} from \"socket.io\";\nimport {GridFSBucket, ObjectId} from \"mongodb\";\nimport {Document} from \"mongoose\";\nimport mongoose from \"mongoose\";\nimport {PassThrough, Readable, ReadableOptions} from \"stream\";\nimport sharp_, {Region} from \"sharp\";\nimport {HttpError} from \"routing-controllers\";\nimport axios from \"axios\";\nimport {AnyWebByteStream} from \"strtok3\";\nimport {fileTypeFromStream as ftFromStream, fileTypeFromBuffer as ftFromBuffer} from \"file-type/core\";\nimport {\n    IAssetCropInfo,\n    IAssetImageParams,\n    IAssetMeta,\n    IClientSocket, IDependencyContainer,\n    IFileType,\n    ParamResolver,\n    Type\n} from \"./common-types\";\n\nconst sharp = sharp_;\n\nexport interface IDIContainers {\n    appContainer: IDependencyContainer\n}\n\nexport const diContainers: IDIContainers = {\n    appContainer: null\n};\n\nexport type FilterPredicate = (value: any, key?: any, target?: any, source?: any) => boolean;\n\nexport function isNullOrUndefined(value: any): boolean {\n    return value == null || typeof value == \"undefined\";\n}\n\nexport function isDefined(value: any): boolean {\n    return !isNullOrUndefined(value);\n}\n\nexport function getType(obj: any): string {\n    const regex = new RegExp(\"\\\\s([a-zA-Z]+)\");\n    return Object.prototype.toString.call(obj).match(regex)[1].toLowerCase();\n}\n\nexport function isObject(value: any): boolean {\n    return getType(value) == \"object\";\n}\n\nexport function isArray(value: any): value is Array<any> {\n    return Array.isArray(value);\n}\n\nexport function isBuffer(value: any): value is Buffer {\n    return value instanceof Buffer;\n}\n\nexport function isBoolean(value: any): value is boolean {\n    return typeof value === \"boolean\";\n}\n\nexport function isDate(value: any): value is Date {\n    return !!value && value[Symbol.toPrimitive] && !isNaN(value) && \"undefined\" !== typeof value.getDate;\n}\n\nexport function isPrimitive(value: any): boolean {\n    const type = typeof value;\n    return value == null || (type !== \"object\" && type !== \"function\");\n}\n\nexport function isString(value: any): value is string {\n    return typeof value === \"string\";\n}\n\nexport function isFunction(value: any): value is Function {\n    return typeof value === \"function\";\n}\n\nexport function isConstructor(value: any): boolean {\n    return (value && typeof value === \"function\" && value.prototype && value.prototype.constructor) === value && value.name !== \"Object\";\n}\n\nexport function isType(value: any): value is Type<any> {\n    return isConstructor(value);\n}\n\nexport function isInterface(obj: any, interFaceObject: { [key: string]: string }): boolean {\n    if (!obj || typeof obj !== \"object\" || isArray(obj) || !isObject(interFaceObject)) return false;\n    const keys = Object.keys(interFaceObject);\n    for (const key of keys) {\n        let type = interFaceObject[key] || \"\";\n        if (type.startsWith(\"*\")) {\n            type = type.substr(1);\n            if (obj.hasOwnProperty(key) && getType(obj[key]) !== type) return false;\n        } else if (!obj.hasOwnProperty(key) || getType(obj[key]) !== type) {\n            return false;\n        }\n    }\n    return true;\n}\n\nexport function ucFirst(value: string): string {\n    if (!value) return \"\";\n    return value[0].toUpperCase() + value.substr(1);\n}\n\nexport function lcFirst(value: string): string {\n    if (!value) return \"\";\n    return value[0].toLowerCase() + value.substr(1);\n}\n\nexport function isObjectId(id: string): boolean {\n    return typeof id === \"string\" && id.length == 24 && !isNaN(Number(\"0x\" + id));\n}\n\nexport function firstItem<T>(value: T[]): T {\n    return value[0];\n}\n\nexport function lastItem<T>(value: T[]): T {\n    return value[value.length - 1];\n}\n\nexport function regroup<T>(value: T[], comparator: (a: T, b: T) => boolean): Array<T[]> {\n    const result: Array<T[]> = [];\n    if (!isArray(value) || value.length == 0) return result;\n    value = Array.from(value);\n    result.push([value.shift()]);\n    value.forEach(item => {\n        const group = result.find(g => g.some(a => comparator(a, item)));\n        if (group) {\n            group.push(item);\n            return;\n        }\n        result.push([item]);\n    });\n    return result;\n}\n\nexport function uniqueItems<T>(value: T[]): T[] {\n    return value.filter((v, ix) => value.indexOf(v) === ix);\n}\n\nexport function getValue(obj: any, key: string, defaultValue?: any, treeFallback: boolean = false): any {\n    key = key || \"\";\n    const keys = key.split(\".\");\n    let curKey = \"\";\n    do {\n        curKey += keys.shift();\n        if (isDefined(obj) && isDefined(obj[curKey]) && (typeof obj[curKey] === \"object\" || !keys.length)) {\n            obj = obj[curKey];\n            curKey = \"\";\n        } else if (!keys.length) {\n            defaultValue = typeof defaultValue == \"undefined\" ? key.replace(new RegExp(`${curKey}$`), `{${curKey}}`) : defaultValue;\n            obj = treeFallback ? obj || defaultValue : defaultValue;\n        } else {\n            curKey += \".\";\n        }\n    } while (keys.length);\n    return obj;\n}\n\nexport function groupBy<T>(items: T[], cb: (item: T) => string) {\n    return items.reduce((res, item) => {\n        const group = cb(item);\n        res[group] = res[group] || [];\n        res[group].push(item);\n        return res;\n    }, {});\n}\n\nexport function convertValue(value: any, type: string): any {\n    switch (type) {\n        case \"boolean\":\n            value = typeof value == \"string\" ? value.toLowerCase() : value;\n            return (value == \"no\" || value == \"false\" || value == \"0\") ? false : !!value;\n        case \"number\":\n            const val = parseFloat(value);\n            return isNaN(val) ? 0 : val;\n        case \"array\":\n            try {\n                return JSON.parse(value);\n            } catch (e) {\n                return `${value}`.split(\", \");\n            }\n    }\n    return value;\n}\n\nconst cropInterface = {\n    x: \"number\",\n    y: \"number\",\n    w: \"number\",\n    h: \"number\"\n};\n\nfunction toCropRegion(cropInfo: string | boolean | IAssetCropInfo): Region {\n    let crop = cropInfo as IAssetCropInfo;\n    if (isString(cropInfo)) {\n        try {\n            crop = JSON.parse(cropInfo as string);\n        } catch (e) {\n            return null;\n        }\n    }\n    if (!isInterface(crop, cropInterface)) return null;\n    return {\n        width: Math.round(crop.w),\n        height: Math.round(crop.h),\n        top: Math.round(crop.y),\n        left: Math.round(crop.x)\n    };\n}\n\nexport async function toImage<T = Buffer | Readable>(src: T, params?: IAssetImageParams, meta?: IAssetMeta): Promise<T> {\n\n    // Default params and meta\n    params = params || {};\n    meta = meta || {};\n\n    // Get default crop info\n    const crop = toCropRegion(meta.crop);\n\n    // Return the src if there are no params and no default crop exists\n    if (meta.extension === \"svg\" || (Object.keys(params).length == 0 && !crop)) {\n        return src;\n    }\n\n    // Parse params\n    params.rotation = isNaN(params.rotation) ? 0 : Math.round(params.rotation / 90) * 90;\n    params.canvasScaleX = isNaN(params.canvasScaleX) ? 1 : Number(params.canvasScaleX);\n    params.canvasScaleY = isNaN(params.canvasScaleY) ? 1 : Number(params.canvasScaleY);\n    params.scaleX = isNaN(params.scaleX) ? 1 : Number(params.scaleX);\n    params.scaleY = isNaN(params.scaleY) ? 1 : Number(params.scaleY);\n    params.crop = isBoolean(params.crop) ? params.crop : params.crop == \"true\";\n\n    let buffer = src instanceof Readable ? await streamToBuffer(src) : src as any;\n    try {\n        // Get crop info\n        const cropBefore = toCropRegion(params.cropBefore || (params.crop ? meta.cropBefore : null));\n        const cropAfter = toCropRegion(params.cropAfter || (params.crop ? meta.cropAfter : null));\n        // Get metadata\n        let img = sharp(buffer);\n        let {width, height} = await img.metadata();\n        // Crop before resize\n        if (cropBefore) {\n            width = cropBefore.width;\n            height = cropBefore.height;\n            img = img.extract(cropBefore);\n        } else if (crop) {\n            width = crop.width;\n            height = crop.height;\n            img = img.extract(crop);\n        }\n        // Resize canvas\n        const canvasScaleX = meta?.canvasScaleX || 1;\n        const canvasScaleY = meta?.canvasScaleY || 1;\n        if (params.canvasScaleX !== canvasScaleX || params.canvasScaleY !== canvasScaleY) {\n            width = Math.round(width * params.canvasScaleX);\n            height = Math.round(height * params.canvasScaleY);\n            img = img.resize({width, height, background: \"#00000000\", fit: \"contain\"});\n        }\n        // Resize image\n        if (params.scaleX !== 1 || params.scaleY !== 1) {\n            width = Math.round(width * params.scaleX);\n            height = Math.round(height * params.scaleY);\n            img = img.resize({width, height, background: \"#00000000\", fit: \"fill\"});\n        }\n        // Crop after resize\n        if (cropAfter) {\n            img = img.extract(cropAfter);\n        }\n        // Rotate\n        if (params.rotation !== 0) {\n            buffer = await img.toBuffer();\n            img = sharp(buffer).rotate(params.rotation);\n        }\n        buffer = await img.toBuffer();\n        src = src instanceof Readable ? bufferToStream(buffer) : buffer;\n        return src;\n    } catch (e) {\n        console.log(\"Image conversion error\", e);\n        src = src instanceof Readable ? bufferToStream(buffer) : buffer;\n        return src;\n    }\n}\n\nexport function bufferToStream(buffer: Buffer): Readable {\n    const readStream = new PassThrough();\n    readStream.end(buffer);\n    return readStream\n}\n\nexport function streamToBuffer(stream: Readable): Promise<Buffer> {\n    return new Promise<Buffer>((resolve, reject) => {\n        const concat = [];\n        stream.on(\"data\", data => {\n            concat.push(data);\n        });\n        stream.on(\"error\", reject);\n        stream.on(\"end\", () => resolve(Buffer.concat(concat)));\n    })\n}\n\nclass ReadableStreamClone extends Readable {\n\n    constructor(readableStream: Readable, opts?: ReadableOptions) {\n        super(opts);\n        readableStream?.on(\"data\", chunk => {\n            this.push(chunk);\n        });\n        readableStream?.on(\"end\", () => {\n            this.push(null);\n        });\n        readableStream?.on(\"error\", err => {\n            this.emit(\"error\", err);\n        });\n    }\n\n    _read(size: number) {\n\n    }\n}\n\nexport function copyStream(stream: Readable, opts?: ReadableOptions): Readable {\n    return new ReadableStreamClone(stream, opts);\n}\n\nexport function mkdirRecursive(path: string, mode: number = null): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n        mkdir(path, {mode: mode || 0o777, recursive: true}, err => {\n            if (err) {\n                reject(err);\n                return;\n            }\n            resolve();\n        });\n    });\n}\n\nexport function deleteFile(path: string): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n        unlink(path, err => {\n            if (err) {\n                reject(err);\n                return;\n            }\n            resolve();\n        });\n    });\n}\n\nexport function readFile(path: string): Promise<Buffer> {\n    return new Promise<Buffer>((res, rej) => {\n        fsReadFile(path, (err, data) => {\n            if (err) {\n                rej(err);\n                return;\n            }\n            res(data);\n        });\n    });\n}\n\nexport async function readAndDeleteFile(path: string, timeout: number = 5000): Promise<Buffer> {\n    const data = await readFile(path);\n    setTimeout(() => {\n        unlink(path, () => {\n        });\n    }, timeout);\n    return data;\n}\n\nexport async function writeFile(path: string, data: Buffer): Promise<Buffer> {\n    await mkdirRecursive(dirname(path));\n    return new Promise<Buffer>((res, rej) => {\n        fsWriteFile(path, data, err => {\n            if (err) {\n                rej(err);\n                return;\n            }\n            res(data);\n        });\n    });\n}\n\nexport function valueToPromise(value: any): Promise<any> {\n    return value instanceof Promise ? value : Promise.resolve(value);\n}\n\nexport function promiseTimeout(timeout: number = 1000, error: boolean = false): Promise<string> {\n    return new Promise<any>((resolve, reject) => {\n        setTimeout(() => {\n            if (error) {\n                reject(`Timeout exceeded: ${timeout}ms`);\n                return;\n            }\n            resolve(`Timeout: ${timeout}ms`);\n        }, timeout);\n    });\n}\n\nexport function getConstructorName(type: Type<any>): string {\n    return type.prototype.constructor.name;\n}\n\nexport function getFunctionParams(func: Function): string[] {\n    // Remove comments of the form /* ... */\n    // Removing comments of the form //\n    // Remove body of the function { ... }\n    // removing \"=>\" if func is arrow function\n    const str = func.toString()\n        .replace(/\\/\\*[\\s\\S]*?\\*\\//g, \"\")\n        .replace(/\\/\\/(.)*/g, \"\")\n        .replace(/{[\\s\\S]*}/, \"\")\n        .replace(/=>/g, \"\")\n        .trim();\n\n    // Start parameter names after first \"(\"\n    const start = str.indexOf(\"(\") + 1;\n\n    // End parameter names is just before last \")\"\n    const end = str.length - 1;\n    const result = str.substring(start, end).split(\", \");\n    const params = [];\n\n    result.forEach(element => {\n\n        // Removing any default value\n        element = element.replace(/=[\\s\\S]*/g, \"\").trim();\n\n        if (element.length > 0)\n            params.push(element);\n    });\n\n    return params;\n}\n\nexport function getFileName(path: string, withExtension: boolean = false): string {\n    const name = basename(path || \"\");\n    return withExtension ? name : name.split(\".\").slice(0, -1).join(\".\");\n}\n\nexport function getExtension(path: string): string {\n    const name = basename(path || \"\");\n    return name.split(\".\").pop();\n}\n\nexport function createIdString(): any {\n    return new ObjectId().toHexString();\n}\n\nexport function idToString(value: any): any {\n    if (Array.isArray(value)) {\n        return value.map(idToString);\n    }\n    return value instanceof ObjectId || value instanceof mongoose.Types.ObjectId\n        ? value.toHexString()\n        : (isString(value) ? value : value || null);\n}\n\nexport function createTransformer(transform?: (doc: Document, ret: any, options?: any) => any) {\n    return (doc: Document, ret: any, options?: any) => {\n        ret.id = idToString(ret.id) || ret.id;\n        if (doc._id) {\n            ret._id = idToString(doc._id);\n            ret.id = ret.id || ret._id;\n        }\n        delete ret.__v;\n        return isFunction(transform) ? transform(doc, ret, options) || ret : ret;\n    };\n}\n\nexport function broadcast(socketServer: Server, cb: (client: IClientSocket) => void): void {\n    socketServer.sockets.sockets.forEach((client: IClientSocket) => {\n        cb(client);\n    });\n}\n\nexport function rand(min: number, max: number): number {\n    return Math.round(random(min, max));\n}\n\nexport function random(min: number, max: number): number {\n    return min + Math.random() * (max - min);\n}\n\nexport function multiSubscription(...subscriptions: Subscription[]): Subscription {\n    return new Subscription(() => {\n        subscriptions.forEach(s => {\n            s.unsubscribe();\n        });\n    });\n}\n\nexport function observableFromFunction(callbackFunc: () => any): Observable<any> {\n    let subject: any;\n    return new Observable<any>((subscriber) => {\n        if (!subject) {\n            subject = new Subject();\n            try {\n                subject = from(callbackFunc());\n            } catch (err) {\n                subject.error(err);\n            }\n        }\n        return subject.subscribe(subscriber);\n    });\n}\n\nexport function padLeft(value: any, count: number = 3, padWith: string = \"0\"): string {\n    return `${value}`.padStart(count, padWith);\n}\n\nexport function padRight(value: any, count: number = 3, padWith: string = \"0\"): string {\n    return `${value}`.padEnd(count, padWith);\n}\n\nexport function camelCaseToDash(str: string): string {\n    return str.replace(/([a-z])([A-Z])/g, \"$1-$2\").toLowerCase();\n}\n\nexport function gzipPromised(data: string, opts?: ZlibOptions): Promise<string> {\n    return new Promise((resolve, reject) => {\n        gzip(data, opts, (err, result) => {\n            if (err) {\n                reject(err);\n                return;\n            }\n            resolve(result.toString(\"base64\"));\n        });\n    });\n}\n\nexport function gunzipPromised(data: string, opts?: ZlibOptions): Promise<string> {\n    return new Promise((resolve, reject) => {\n        gunzip(Buffer.from(data, \"base64\"), opts, (err, result) => {\n            if (err) {\n                reject(err);\n                return;\n            }\n            resolve(result.toString(\"utf8\"));\n        });\n    });\n}\n\nexport function deleteFromBucket(bucket: GridFSBucket, id: ObjectId | string): Promise<string> {\n    const fileId = id instanceof ObjectId ? id : new ObjectId(id);\n    return new Promise<string>(((resolve, reject) => {\n        if (!id) {\n            // We don't care about empty id\n            resolve(null);\n            return;\n        }\n        bucket.delete(fileId, error => {\n            let err = error as any;\n            if (error) {\n                err = error.message || error || \"\";\n                if (!isString(err) || !err.startsWith(\"FileNotFound\")) {\n                    reject(err);\n                    return;\n                }\n            }\n            resolve(fileId.toHexString());\n        });\n    }));\n}\n\nconst defaultPredicate: FilterPredicate = () => true;\n\nfunction copyRecursive(target: any, source: any, predicate: FilterPredicate, copies: Map<any, any>): any {\n    if (isPrimitive(source) || isDate(source) || isFunction(source)) return source;\n    if (copies.has(source)) return copies.get(source);\n    if (isArray(source)) {\n        target = isArray(target) ? Array.from(target) : [];\n        source.forEach((item, index) => {\n            if (!predicate(item, index, target, source)) return;\n            if (target.length > index)\n                target[index] = copyRecursive(target[index], item, predicate, copies);\n            else\n                target.push(copyRecursive(null, item, predicate, copies));\n        });\n        copies.set(source, target);\n        return target;\n    }\n    if (isBuffer(source)) return Buffer.from(source);\n\n    // If object defines __shouldCopy as false, then don't copy it\n    if (source.__shouldCopy === false) return source;\n    // Copy object\n    const shouldCopy = isFunction(source.__shouldCopy) ? source.__shouldCopy : () => true;\n    if (isConstructor(source.constructor)) {\n        if (!target) {\n            try {\n                target = new source.constructor();\n            } catch (e) {\n                const proto = source.constructor.prototype || source.prototype;\n                target = Object.create(proto);\n            }\n        }\n    } else {\n        target = Object.assign({}, target || {});\n    }\n    // Set to copies to prevent circular references\n    copies.set(source, target);\n\n    // Copy map entries\n    if (target instanceof Map) {\n        if (source instanceof Map) {\n            for (let [key, value] of source.entries()) {\n                if (!predicate(value, key, target, source)) continue;\n                target.set(key, !shouldCopy(key, value) ? value : copyRecursive(target.get(key), value, predicate, copies));\n            }\n        }\n        return target;\n    }\n\n    // Copy object members\n    let keys = Object.keys(source);\n    keys.forEach(key => {\n        if (!predicate(source[key], key, target, source)) return;\n        target[key] = !shouldCopy(key, source[key]) ? source[key] : copyRecursive(target[key], source[key], predicate, copies);\n    }, target);\n\n    // Copy object properties\n    const descriptors = Object.getOwnPropertyDescriptors(source);\n    keys = Object.keys(descriptors).filter(k => keys.indexOf(k) < 0);\n    keys.forEach(key => {\n        Object.defineProperty(target, key, descriptors[key]);\n    });\n    return target;\n}\n\nexport function filter<T>(obj: T, predicate: FilterPredicate): Partial<T> {\n    return copyRecursive(null, obj, predicate || defaultPredicate, new Map());\n}\n\nexport function copy<T>(obj: T): T {\n    return copyRecursive(null, obj, defaultPredicate, new Map());\n}\n\nexport function assign<T>(target: T, source: any, predicate?: FilterPredicate): T {\n    return copyRecursive(target, source, predicate, new Map());\n}\n\nexport function md5(data: any): string {\n    if (isObject(data)) {\n        data = JSON.stringify(data);\n    }\n    if (!isString(data)) {\n        throw `Can't md5 other that raw object or string`;\n    }\n    return createHash(\"md5\").update(data).digest(\"hex\");\n}\n\nexport function runCommand(scriptPath: string, expectedCode: number = 0): Promise<string> {\n    return new Promise((resolve, reject) => {\n        const cp = execChildProcess(scriptPath, (error, stdout) => {\n            if (error && expectedCode !== error.code) {\n                console.log(error);\n                reject(error);\n                return;\n            }\n            const lines = (stdout || \"\").split(\"\\n\");\n            let line = null;\n            while (!line && lines.length > 0) {\n                line = lines.pop();\n            }\n            resolve(line);\n        });\n        cp.stdout.on(\"data\", function (data) {\n            console.log(data.toString());\n        });\n        cp.stderr.on(\"data\", function (data) {\n            console.error(data.toString());\n        });\n    });\n}\n\nexport enum ConsoleColor {\n    Reset = \"\\x1b[0m\",\n    Bright = \"\\x1b[1m\",\n    Dim = \"\\x1b[2m\",\n    Underscore = \"\\x1b[4m\",\n    Blink = \"\\x1b[5m\",\n    Reverse = \"\\x1b[7m\",\n    Hidden = \"\\x1b[8m\",\n\n    FgBlack = \"\\x1b[30m\",\n    FgRed = \"\\x1b[31m\",\n    FgGreen = \"\\x1b[32m\",\n    FgYellow = \"\\x1b[33m\",\n    FgBlue = \"\\x1b[34m\",\n    FgMagenta = \"\\x1b[35m\",\n    FgCyan = \"\\x1b[36m\",\n    FgWhite = \"\\x1b[37m\",\n    FgDefault = \"\\x1b[38m\",\n\n    BgBlack = \"\\x1b[40m\",\n    BgRed = \"\\x1b[41m\",\n    BgGreen = \"\\x1b[42m\",\n    BgYellow = \"\\x1b[43m\",\n    BgBlue = \"\\x1b[44m\",\n    BgMagenta = \"\\x1b[45m\",\n    BgCyan = \"\\x1b[46m\",\n    BgWhite = \"\\x1b[47m\",\n    BgDefault = \"\\x1b[48m\"\n}\n\nexport interface IJsonColors {\n    keyColor?: ConsoleColor;\n    numberColor?: ConsoleColor;\n    stringColor?: ConsoleColor;\n    trueColor?: ConsoleColor;\n    falseColor?: ConsoleColor;\n    nullColor?: ConsoleColor;\n}\n\nconst defaultColors: IJsonColors = {\n    keyColor: ConsoleColor.FgWhite,\n    numberColor: ConsoleColor.FgBlue,\n    stringColor: ConsoleColor.FgYellow,\n    trueColor: ConsoleColor.FgGreen,\n    falseColor: ConsoleColor.FgRed,\n    nullColor: ConsoleColor.BgMagenta\n}\n\nexport function colorize(input: any, color: ConsoleColor): string {\n    return `${color}${input}${ConsoleColor.Reset}`;\n}\n\nexport function jsonHighlight(input: string | object, colorOptions?: IJsonColors): string {\n    const colors = Object.assign({}, defaultColors, colorOptions)\n    const json = (isString(input) ? input : JSON.stringify(input, null, 2)).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>')\n    return json.replace(/(\"(\\\\u[a-zA-Z0-9]{4}|\\\\[^u]|[^\\\\\"])*\"(\\s*:)?|\\b(true|false|null)\\b|-?\\d+(?:\\.\\d*)?(?:[eE][+]?\\d+)?)/g, (match) => {\n        let color = colors.numberColor\n        if (/^\"/.test(match)) {\n            if (/:$/.test(match)) {\n                color = colors.keyColor\n            } else {\n                color = colors.stringColor;\n                match = '\"' + match.substr(1, match.length - 2) + '\"';\n            }\n        } else {\n            color = /true/.test(match)\n                ? colors.trueColor\n                : /false/.test(match)\n                    ? colors.falseColor\n                    : /null/.test(match)\n                        ? colors.nullColor\n                        : color\n        }\n        return `${color}${match}${ConsoleColor.Reset}`\n    })\n}\n\nexport function replaceSpecialChars(str: string, to: string = \"-\"): string {\n    return `${str}`.replace(/[&\\/\\\\#, +()$~%.@'\":*?<>{}]/g, to);\n}\n\nexport function regexEscape(str: string): string {\n    return `${str}`.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n}\n\nexport function flatten(arr: any[]): any[] {\n    return arr.reduce((flat, toFlatten) => {\n        return flat.concat(isArray(toFlatten) ? flatten(toFlatten) : toFlatten);\n    }, []);\n}\n\nexport function wrapError(e: any, message: string, httpCode: number = 500): Error {\n    if (axios.isAxiosError(e)) {\n        e.message = message;\n        return e;\n    }\n    return new HttpError(httpCode, `${message}: ${e}`);\n}\n\nexport function getDirName(): string {\n    if (typeof __dirname === \"undefined\") {\n        const __filename = fileURLToPath(import.meta.url);\n        return dirname(__filename);\n    }\n    return __dirname;\n}\n\nexport function prepareUrl(ending: string = \"/\"): ParamResolver {\n    return url => {\n        return url ? `${url.replace(/\\/+$/, \"\")}${ending}` : ending;\n    }\n}\n\nexport const prepareUrlSlash = prepareUrl(\"/\");\n\nexport const prepareUrlEmpty = prepareUrl(\"\");\n\nfunction checkTextFileType(type: IFileType): boolean {\n    return type.mime.indexOf(\"text\") >= 0 || type.mime.indexOf(\"xml\") >= 0;\n}\n\nfunction fixTextFileType(type: IFileType, buffer: Buffer): IFileType {\n    const text = buffer.toString(\"utf8\");\n    if (text.indexOf(\"<svg\") >= 0) {\n        return {ext: \"svg\", mime: \"image/svg+xml\"};\n    }\n    return type;\n}\n\nexport async function fileTypeFromBuffer(buffer: Buffer): Promise<IFileType> {\n    const stream = bufferToStream(buffer);\n    const type = (await ftFromBuffer(buffer) ?? {ext: \"txt\", mime: \"text/plain\"}) as IFileType;\n    if (checkTextFileType(type)) {\n        return fixTextFileType(type, buffer);\n    }\n    return type;\n}\n\nexport async function fileTypeFromStream(stream: AnyWebByteStream): Promise<IFileType> {\n    return (await ftFromStream(stream) ?? {ext: \"txt\", mime: \"text/plain\"}) as IFileType;\n}\n"]}