mybase 1.1.34 → 1.1.36

package/ts/funcs/isLoopbackIP.test.ts

@@ -0,0 +1,72 @@
+import { randomIP } from './randomIP';
+import { isLoopbackIP } from './isLoopbackIP';
+
+describe('isLoopbackIP', () => {
+    test('should return true for loopback IPv4 address', () => {
+        expect(isLoopbackIP('127.0.0.1')).toBe(true);
+    });
+
+    test('should return true for loopback IPv6 address', () => {
+        expect(isLoopbackIP('::1')).toBe(true);
+    });
+
+    test('should return false for non-loopback IPv4 address', () => {
+        expect(isLoopbackIP('192.168.0.1')).toBe(false);
+    });
+
+    test('should return false for non-loopback IPv6 address', () => {
+        expect(isLoopbackIP('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBe(false);
+    });
+
+    test('should return false for invalid IP address', () => {
+        expect(isLoopbackIP('invalid')).toBe(false);
+    });
+
+    test('should return true for local IPv4', () => {
+        const ip = '127.0.0.1'
+        expect(isLoopbackIP(ip)).toBe(true)
+    })
+
+    test('should return true for local IPv4', () => {
+        const ip = '127.2.0.1'
+        expect(isLoopbackIP(ip)).toBe(true)
+    })
+
+    test('should return true for local IPv4', () => {
+        const ip = '127.255.0.1'
+        expect(isLoopbackIP(ip)).toBe(true)
+    })
+
+    test('should return true for local IPv4', () => {
+        const ip = '127.127.127.127'
+        expect(isLoopbackIP(ip)).toBe(true)
+    })
+
+    test('should return true for local IPv6', () => {
+        const ip = '::1'
+        expect(isLoopbackIP(ip)).toBe(true)
+    })
+
+    test('should return null for non-local IPv4', () => {
+        const ip = '8.8.8.8'
+        expect(isLoopbackIP(ip)).toBe(false)
+    })
+
+    test('should return null for non-local IPv6', () => {
+        const ip = '2001:4860:4860::8888'
+        expect(isLoopbackIP(ip)).toBe(false)
+    })
+
+    test('should return false for invalid IP', () => {
+        const ip = 'invalid'
+        expect(isLoopbackIP(ip)).toBe(false)
+    })
+
+    test('random ips should not be Loopback', () => {
+        for(let i=0;i<10;i++){
+            let ip = randomIP()
+            expect(isLoopbackIP(ip)).toBe(false)
+        }
+            
+    })
+});

package/ts/funcs/isLoopbackIP.ts

@@ -0,0 +1,32 @@
+import ip6addr from 'ip6addr'
+import net from 'net'
+
+export const local_network_cidrs = [
+    ip6addr.createCIDR('127.0.0.0/8'),
+    ip6addr.createCIDR('::1/128')
+]
+
+export function isLoopbackIP(ip:string) : boolean {
+    ip=normalizeIp(ip)
+    if (net.isIP(ip)===0) return false
+    try {
+        // speed optimized
+        let ipVersion = net.isIPv4(ip) ? 'ipv4' : 'ipv6'
+        for (let cidr of local_network_cidrs) {
+            let first = cidr.first()
+            if (first.kind() !== ipVersion) continue
+            if (cidr.contains(ip))
+                return true
+        }
+    } catch (err) {
+        console.log(err)
+    }
+    return false
+}
+
+function normalizeIp(ip:string):string {
+    // also support ipv6
+    if (net.isIP(ip) === 0) return ''
+    if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
+    return ip
+}

package/ts/funcs/promiseTimeout.d.ts

@@ -0,0 +1 @@
+export declare function promiseTimeout(miliseconds: number, inputPromise: Promise<any>, onTimeout?: any): Promise<any>;

package/ts/funcs/promiseTimeout.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+function promiseTimeout(miliseconds, inputPromise, onTimeout = 'TIMEDOUT') {
+    // Create a promise that rejects in <miliseconds> milliseconds
+    let timeout = new Promise((resolve, reject) => {
+        let stID = setTimeout(() => {
+            clearTimeout(stID);
+            reject(onTimeout);
+        }, miliseconds);
+    });
+    // Returns a race between our timeout and the passed in promise
+    return Promise.race([
+        inputPromise,
+        timeout
+    ]);
+}
+exports.promiseTimeout = promiseTimeout;
+//# sourceMappingURL=promiseTimeout.js.map

package/ts/funcs/promiseTimeout.test.js

@@ -0,0 +1,104 @@
+const { promiseTimeout } = require('./promiseTimeout');
+
+describe('promiseTimeout', () => {
+
+  // Returns a promise that resolves when inputPromise resolves before the timeout.
+  it('should resolve when inputPromise resolves before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve('Resolved');
+      }, 100);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).resolves.toBe('Resolved');
+  });
+
+  // Returns a promise that rejects with onTimeout when inputPromise rejects after the timeout.
+  it('should reject with onTimeout when inputPromise rejects after the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject('Rejected');
+      }, 200);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(100, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('TIMEDOUT');
+  });
+
+  // Returns a promise that rejects with onTimeout when inputPromise is pending after the timeout.
+  it('should reject with onTimeout when inputPromise is pending after the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise(() => { });
+
+    // Act
+    const resultPromise = promiseTimeout(100, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('TIMEDOUT');
+  });
+
+  // Returns a promise that resolves with inputPromise value when inputPromise resolves before the timeout.
+  it('should resolve with inputPromise value when inputPromise resolves before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve('Resolved');
+      }, 100);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).resolves.toBe('Resolved');
+  });
+
+  // Returns a promise that rejects with inputPromise value when inputPromise rejects before the timeout.
+  it('should reject with inputPromise value when inputPromise rejects before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject('Rejected');
+      }, 100);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('Rejected');
+  });
+
+  // Returns a promise that rejects with inputPromise value when inputPromise is pending before the timeout.
+  it('should reject with inputPromise value when inputPromise is pending before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise(() => { });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('TIMEDOUT');
+  });
+
+  // Returns a promise that resolves with undefined when inputPromise is undefined.
+  it('should resolve with undefined when inputPromise is undefined', () => {
+    // Arrange
+    const inputPromise = undefined;
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).resolves.toBe(undefined);
+  });
+});

package/ts/funcs/promiseTimeout.ts

@@ -0,0 +1,19 @@
+
+
+
+
+export function promiseTimeout(miliseconds:number, inputPromise:Promise<any>, onTimeout:any='TIMEDOUT') { // ported
+    // Create a promise that rejects in <miliseconds> milliseconds
+    let timeout = new Promise((resolve, reject) => {
+        let stID = setTimeout(() => {
+            clearTimeout(stID);
+            reject(onTimeout)
+        }, miliseconds)
+    })
+
+    // Returns a race between our timeout and the passed in promise
+    return Promise.race([
+        inputPromise,
+        timeout
+    ])
+}

package/ts/funcs/randomIP.d.ts

@@ -0,0 +1 @@
+export declare function randomIP(): string;

package/ts/funcs/randomIP.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomIP = void 0;
+function randomIP() {
+    function int2ip(ipInt) {
+        return ((ipInt >>> 24) + '.' + (ipInt >> 16 & 255) + '.' + (ipInt >> 8 & 255) + '.' + (ipInt & 255));
+    }
+    return int2ip(Math.random() * Math.pow(2, 32));
+}
+exports.randomIP = randomIP;
+//# sourceMappingURL=randomIP.js.map

package/ts/funcs/randomIP.test.ts

@@ -0,0 +1,16 @@
+import { randomIP } from './randomIP';
+
+describe('randomIP', () => {
+  it('should return a valid IP address', () => {
+    for(let i=0; i<1000; i++) {
+        const ipAddress = randomIP();
+        const ipParts = ipAddress.split('.');
+        expect(ipParts.length).toBe(4);
+        ipParts.forEach((part) => {
+          const partInt = parseInt(part);
+          expect(partInt).toBeGreaterThanOrEqual(0);
+          expect(partInt).toBeLessThanOrEqual(255);
+        });
+    }
+  });
+});

package/ts/funcs/randomIP.ts

@@ -0,0 +1,10 @@
+
+export function randomIP() : string {
+    function int2ip (ipInt: number) {
+        return ( (ipInt>>>24) +'.' + (ipInt>>16 & 255) +'.' + (ipInt>>8 & 255) +'.' + (ipInt & 255) );
+    }
+    return int2ip(Math.random()*Math.pow(2,32))
+}
+
+
+

package/ts/funcs/randomIP6.d.ts

@@ -0,0 +1 @@
+export declare function randomIP6(): string;

package/ts/funcs/randomIP6.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomIP6 = void 0;
+const crypto_1 = require("crypto");
+// const ip6 = require('ip6')
+//@ts-ignore
+const ip6_1 = __importDefault(require("ip6"));
+function randomIP6() {
+    var _a;
+    const bytes = (0, crypto_1.randomBytes)(16);
+    return ip6_1.default.abbreviate(ip6_1.default.normalize(((_a = bytes.toString('hex').match(/.{1,4}/g)) === null || _a === void 0 ? void 0 : _a.join(':')) || '0000:0000:0000:0000:0000:0000:0000:0000'));
+}
+exports.randomIP6 = randomIP6;
+//# sourceMappingURL=randomIP6.js.map

package/ts/funcs/randomIP6.test.js

@@ -0,0 +1,18 @@
+const ip6 = require('ip6');
+const { randomIP6 } = require('./randomIP6');
+
+describe('randomIP6', () => {
+  it('should generate a random IPv6 address', () => {
+    const result = randomIP6();
+    expect(()=>ip6.normalize(result)).not.toThrow()
+    expect(()=>ip6.abbreviate(result)).not.toThrow()
+  });
+
+  it('generate 100 ipv6', () => {
+    for (let i = 0; i < 100; i++) {
+      const result = randomIP6();
+      expect(()=>ip6.normalize(result)).not.toThrow()
+      expect(()=>ip6.abbreviate(result)).not.toThrow()
+    }
+  })
+});

package/ts/funcs/randomIP6.ts

@@ -0,0 +1,12 @@
+import { randomBytes } from "crypto"
+// const ip6 = require('ip6')
+//@ts-ignore
+import ip6 from 'ip6'
+
+export function randomIP6() : string {
+    const bytes = randomBytes(16)
+    return ip6.abbreviate(ip6.normalize(bytes.toString('hex').match(/.{1,4}/g)?.join(':') || '0000:0000:0000:0000:0000:0000:0000:0000'))
+}
+
+
+

package/ts/funcs/randomString.d.ts

@@ -0,0 +1 @@
+export declare function randomString(length?: number, charSet?: string): string;

package/ts/funcs/randomString.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomString = void 0;
+function randomString(length = 10, charSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+    return Array.from({ length }, () => charSet.charAt(Math.floor(Math.random() * charSet.length))).join('');
+}
+exports.randomString = randomString;
+//# sourceMappingURL=randomString.js.map

package/ts/funcs/randomString.test.ts

@@ -0,0 +1,15 @@
+import { randomString } from "./randomString";
+
+test('randomString', () => {
+    // Test default length and character set
+    expect(randomString()).toHaveLength(10);
+    expect(randomString()).toMatch(/^[A-Za-z0-9]{10}$/);
+
+    // Test custom length and character set
+    expect(randomString(5, "abc")).toHaveLength(5);
+    expect(randomString(5, "abc")).toMatch(/^[abc]{5}$/);
+
+    // Test empty character set
+    expect(randomString(10, "")).toHaveLength(0);
+    expect(randomString(10, "")).toMatch(/^$/);
+});

package/ts/funcs/randomString.ts

@@ -0,0 +1,5 @@
+
+
+export function randomString(length = 10, charSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"): string {
+    return Array.from({ length }, () => charSet.charAt(Math.floor(Math.random() * charSet.length))).join('');
+}

package/ts/funcs/randomTCPPort.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This function returns a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
+ * this port number immediately
+ * This function should be used for testing purposes only
+ * This function is not suitable for production use
+ * @param timeout the timeout for each port check
+ * @param fromPort the first port number to check defaults to 1025
+ * @param untilPort the last port number to check defaults to 65534
+ * @param tries the number of tries to find a port number
+ * @param host the host to bind to
+ */
+export declare function randomTCPPort(timeout?: number, fromPort?: number, untilPort?: number, tries?: number, host?: string): Promise<number | false>;

package/ts/funcs/randomTCPPort.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomTCPPort = void 0;
+const net = __importStar(require("net"));
+/**
+ * This function returns a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
+ * this port number immediately
+ * This function should be used for testing purposes only
+ * This function is not suitable for production use
+ * @param timeout the timeout for each port check
+ * @param fromPort the first port number to check defaults to 1025
+ * @param untilPort the last port number to check defaults to 65534
+ * @param tries the number of tries to find a port number
+ * @param host the host to bind to
+ */
+async function randomTCPPort(timeout = 1000, fromPort = 1025, untilPort = 65534, tries = 1000, host = '127.0.0.1') {
+    return new Promise(async function (resolve, reject) {
+        // check if the given port range is valid
+        if (fromPort > untilPort)
+            return resolve(false);
+        // check if the given port range is valid
+        if (fromPort < 0 || untilPort < 0)
+            return resolve(false);
+        // check if the given port range is valid
+        if (fromPort > 65535 || untilPort > 65535)
+            return resolve(false);
+        // this function shall return a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
+        // this port number immediately
+        // this function should be used for testing purposes only
+        // this function is not suitable for production use
+        while (true && tries > 0) {
+            tries--;
+            let port = Math.floor(Math.random() * (untilPort - fromPort + 1) + fromPort);
+            let server = net.createServer();
+            let checkPort = new Promise((resolveInner, reject) => {
+                server.on('error', (err) => {
+                    // any error should raise problem
+                    resolveInner(false);
+                });
+                server.on('listening', () => {
+                    resolveInner(true);
+                });
+            });
+            server.listen(port, host);
+            let result = await checkPort;
+            if (result) {
+                let to = setTimeout(() => {
+                    return resolve(port);
+                }, 1000);
+                server.on('close', () => {
+                    clearTimeout(to);
+                    return resolve(port);
+                });
+                server.close();
+                return;
+            }
+            else
+                server.close();
+        }
+        if (tries === 0)
+            return resolve(false);
+    });
+}
+exports.randomTCPPort = randomTCPPort;
+//# sourceMappingURL=randomTCPPort.js.map

package/ts/funcs/randomTCPPort.test.ts

@@ -0,0 +1,62 @@
+import { wait } from "./wait";
+import { randomTCPPort } from "./randomTCPPort";
+
+
+describe("randomTCPPort", () => {
+  let fromPort = 15000;
+  let untilPort = fromPort+1000;
+  let hostToBind="127.0.0.1"
+
+  beforeEach(() => {
+    untilPort = fromPort+1000;
+  })
+
+  test("should return a random port number within the given range", async () => {
+    const port = await randomTCPPort(1000, fromPort, untilPort, 1000, hostToBind);
+    expect(port).toBeGreaterThanOrEqual(fromPort);
+    expect(port).toBeLessThanOrEqual(untilPort);
+  });
+
+  test("should return false if no available port is found", async () => {
+    untilPort = fromPort+1;
+    // listen to the port 15000 and 15001 to simulate that these ports are in use
+    const server1 = require("net").createServer();
+    const server2 = require("net").createServer();
+    server1.listen(fromPort, hostToBind);
+    server2.listen(untilPort, hostToBind);
+    // try to find a port within the range
+    const port = await randomTCPPort(1000, fromPort, untilPort, 1000, hostToBind);
+    expect(port).toBe(false);
+    server1.close();
+    server2.close();
+    await wait(1/100)
+    const port2 = await randomTCPPort(1000, fromPort, untilPort, 1000, hostToBind);
+    expect(port2===fromPort || port2===untilPort).toBe(true);
+  });
+
+  test("should handle errors when trying to listen to a port", async () => {
+    const port = await randomTCPPort(1000, fromPort, untilPort, 1000, "invalid-host");
+    expect(port).toBe(false);
+  })
+
+  test("should return false if the given port range is invalid", async () => {
+    const port = await randomTCPPort(1000, untilPort, fromPort, 1000, hostToBind);
+    expect(port).toBe(false);
+  });
+
+  test("should return false if the given port range is invalid", async () => {
+    const port = await randomTCPPort(1000, -1, untilPort, 1000, hostToBind);
+    expect(port).toBe(false);
+  });
+
+  test("should return false if the given port range is invalid", async () => {
+    const port = await randomTCPPort(1000, fromPort, -1, 1000, hostToBind);
+    expect(port).toBe(false);
+  });
+
+  test("should return false if the given port range is invalid", async () => {
+    const port = await randomTCPPort(1000, fromPort, 65536, 1000, hostToBind);
+    expect(port).toBe(false);
+  });
+
+})

package/ts/funcs/randomTCPPort.ts

@@ -0,0 +1,58 @@
+import * as net from 'net'
+
+/**
+ * This function returns a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
+ * this port number immediately
+ * This function should be used for testing purposes only
+ * This function is not suitable for production use
+ * @param timeout the timeout for each port check
+ * @param fromPort the first port number to check defaults to 1025
+ * @param untilPort the last port number to check defaults to 65534
+ * @param tries the number of tries to find a port number
+ * @param host the host to bind to
+ */
+export async function randomTCPPort(timeout: number = 1000, fromPort: number = 1025, untilPort: number = 65534, tries = 1000, host = '127.0.0.1'): Promise<number | false> {
+    return new Promise(async function (resolve, reject) {
+        // check if the given port range is valid
+        if (fromPort > untilPort) return resolve(false)
+        // check if the given port range is valid
+        if (fromPort < 0 || untilPort < 0) return resolve(false)
+        // check if the given port range is valid
+        if (fromPort > 65535 || untilPort > 65535) return resolve(false)
+
+        // this function shall return a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
+        // this port number immediately
+        // this function should be used for testing purposes only
+        // this function is not suitable for production use
+        while(true && tries > 0) {
+            tries--
+            let port = Math.floor(Math.random() * (untilPort - fromPort + 1) + fromPort)
+            let server = net.createServer()
+            let checkPort = new Promise((resolveInner, reject) => {
+                server.on('error', (err) => {
+                    // any error should raise problem
+                    resolveInner(false)
+                })
+                server.on('listening', () => {
+                    resolveInner(true)
+                })
+            })
+            server.listen(port, host)
+            let result = await checkPort
+            if (result) {
+                let to = setTimeout(() => {
+                    return resolve(port)
+                },1000)
+                server.on('close', () => {
+                    clearTimeout(to)
+                    return resolve(port)
+                })
+                server.close()
+                return
+            } else server.close()
+        }
+        if (tries===0) 
+            return resolve(false)
+    })
+
+}

package/ts/funcs/randomUTFString.d.ts

@@ -0,0 +1 @@
+export declare function randomUTFString(minLength: number, maxLength: number, includeAscii?: boolean): string;

package/ts/funcs/randomUTFString.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomUTFString = void 0;
+function randomUTFString(minLength, maxLength, includeAscii = true) {
+    // Extended characters set including various languages and symbols
+    let characters = 'àáâãäåæçèéêëìíîïðñòóôõöøùúûüýÿ' + // Accented Latin characters
+        'ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩαβγδεζηθικλμνξοπρσςτυφχψω' + // Greek
+        'אבגדהוזחטיךכלםמןנסעפצקרשת' + // Hebrew
+        //Arabic
+        'ا ب ت ث ج ح خ د ذ ر ز س ش ص ض ط ظ ع غ ف ق ك ل م ن ه و ي' +
+        // Persian
+        'آ ا ب پ ت ث ج چ ح خ د ذ ر ز ژ س ش ص ض ط ظ ع غ ف ق ک گ ل م ن و ه ی' +
+        // Turkish
+        'ğıöşü' +
+        'ĞİÖŞÜ ' +
+        // More Emojis
+        '🙂🤔😍😂👍🚀❤️🎉' +
+        'бвгдежзийклмнопрстуфхцчшщъыьэюя' + // Cyrillic (Russian, etc.)
+        '日本語中文한국어' + // Japanese, Chinese, Korean characters
+        '🙂🤔😍😂👍🚀❤️🎉'; // Emojis
+    if (includeAscii)
+        characters += 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    const charactersLength = Array.from(characters).length;
+    const length = Math.floor(Math.random() * (maxLength - minLength + 1)) + minLength;
+    let result = '';
+    for (let i = 0; i < length; i++)
+        result += Array.from(characters)[Math.floor(Math.random() * charactersLength)];
+    return result;
+}
+exports.randomUTFString = randomUTFString;
+//# sourceMappingURL=randomUTFString.js.map