umt 2.6.0 → 2.8.0

package/README.md

@@ -60,6 +60,12 @@ bun add umt
 | zip | `<T extends unknown[][]>(...arrays: T) => ZipArrayType<T>` | Creates a new array by combining elements from multiple arrays at corresponding positions | `zip([1, 2], ['a', 'b']); // [[1, 'a'], [2, 'b']]` |
 | zipLongest | `<T extends unknown[][]>(...arrays: T) => ZipArrayType<T>` | Combines arrays of different lengths by padding shorter arrays with undefined values | `zipLongest([1, 2], ['a']); // [[1, 'a'], [2, undefined]]` |
 
+### DataStructure
+
+| name | type | description | example |
+|------|------|-------------|---------|
+| PriorityQueue | `class PriorityQueue<T>` | A priority queue implementation using a binary heap. Higher priority values are dequeued first. | `const queue = new PriorityQueue<string>(); queue.enqueue("low", 1); queue.enqueue("high", 3); queue.enqueueBack("back"); queue.dequeue(); // "high"` |
+
 ### Color
 
 | name | type | description | example |
@@ -71,6 +77,17 @@ bun add umt
 | rgbaToHexA | `(rgba: { r: number; g: number; b: number; a?: number }) => string` | Convert RGBA color to hexadecimal color code | `rgbaToHexA({ r: 0, g: 0, b: 0, a: 1 }); // "#000000ff"` |
 | rgbaToHsla | `(rgba: { r: number; g: number; b: number; a?: number }) => { h: number; s: number; l: number; a: number }` | Convert RGBA color values to HSLA color space | `rgbaToHsla({ r: 100, g: 100, b: 100, a: 1 }); // { h: 0, s: 0, l: 39.22, a: 1 }` |
 
+### Crypto
+
+| name | type | description | example |
+|------|------|-------------|---------|
+| decodeBase32 | `(input: string) => Uint8Array` | Decodes an uppercase Base32 string to Uint8Array. Does not validate padding placement. | `decodeBase32("JBSWY3DP"); // Uint8Array for "Hello"` |
+| decodeBase32ToString | `(input: string) => string` | Decodes an uppercase Base32 string to a UTF-8 string. Does not validate padding placement. | `decodeBase32ToString("JBSWY3DP"); // "Hello"` |
+| decodeBase58 | `(input: string) => Uint8Array` | Decodes a Base58 string to Uint8Array | `decodeBase58("9Ajdvzr"); // Uint8Array for "Hello"` |
+| decodeBase58ToString | `(input: string) => string` | Decodes a Base58 string to a UTF-8 string | `decodeBase58ToString("9Ajdvzr"); // "Hello"` |
+| encodeBase32 | `(input: string \| Uint8Array) => string` | Encodes a string or Uint8Array to Base32 format | `encodeBase32("Hello"); // "JBSWY3DP"` |
+| encodeBase58 | `(input: string \| Uint8Array) => string` | Encodes a string or Uint8Array to Base58 format | `encodeBase58("Hello"); // "9Ajdvzr"` |
+
 ### Date
 
 | name | type | description | example |
@@ -119,6 +136,7 @@ bun add umt
 |------|------|-------------|---------|
 | addition | `(...numbers: number[]) => number` | Addition without floating point errors | `addition(0.1, 0.2); // 0.3` |
 | average | `(numbers: number[]) => number` | Calculates the arithmetic mean of an array of numbers | `average([1, 2, 3]); // 2` |
+| correlationCoefficient | `(x: number[], y: number[]) => number` | Calculate the Pearson correlation coefficient between two arrays | `correlationCoefficient([1, 2, 3, 4, 5], [2, 4, 6, 8, 10]); // 1` |
 | bitwise | `(x: number, k: number, direction?: "left" \| "right") => number` | Performs bit rotation on a number | `bitwise(0x12345678, 8); // 0x34567812` |
 | calculator | `<T extends Record<string, string \| number>>(expression: string, exchange?: T) => string` | Calculator function that handles mathematical expressions and simple equations | `calculator("1+2"); // "3"` |
 | calculatorInitialization | `<T extends { [key: string]: string \| number }>(exchange: T) => (x: string) => string` | Initializes a calculator function with exchange rates | `calculatorInitialization({ $: 100 })("$1"); // "100"` |
@@ -139,11 +157,13 @@ bun add umt
 | max | `(...number_: number[]) => number` | Returns the maximum value from the input numbers | `max(1, 2, 3); // 3` |
 | median | `(array: number[]) => number` | Calculate the median of an array of numbers | `median([1, 3, 3, 6, 7, 8, 9]); // 6` |
 | min | `(...number_: number[]) => number` | Returns the minimum value from the input numbers | `min(1, 2, 3); // 1` |
+| mode | `(array: number[]) => number[]` | Finds the most frequently occurring value(s) in an array | `mode([1, 2, 2, 3, 3, 3]); // [3]` |
 | multiples | `(x: number, n: number) => number[]` | Generate an array of multiples of a number | `multiples(2, 5); // [2, 4, 6, 8, 10]` |
 | multiplication | `(...numbers: number[]) => number` | Performs multiplication without floating point errors for any number of arguments | `multiplication(0.1, 0.2, 0.3); // 0.006` |
 | nCr | `(n: number, r: number) => number` | Calculates combinations (nCr) - number of ways to choose r items from n items | `nCr(5, 2); // 10` |
 | nHr | `(n: number, r: number) => number` | Calculates combinations with repetition (nHr) | `nHr(5, 2); // 15` |
 | nPr | `(n: number, r: number) => number` | Calculates permutations (nPr) - number of ways to arrange r items from n items | `nPr(5, 2); // 20` |
+| percentile | `(array: number[], percentile: number) => number` | Calculate the nth percentile of values in an array | `percentile([1, 2, 3, 4, 5], 50); // 3` |
 | primeFactorization | `(x: number) => Array<{number: number; count: number}>` | Performs prime factorization of a number | `primeFactorization(12); // [{number: 2, count: 2}, {number: 3, count: 1}]` |
 | quotient | `(x: number, y: number) => number[]` | Computes quotient and remainder of division | `quotient(5, 2); // [2, 1]` |
 | radToDeg | `(x: number) => number` | Converts radians to degrees | `radToDeg(Math.PI); // 180` |
@@ -192,6 +212,7 @@ bun add umt
 | deleteSpaces | `(string_: string) => string` | Removes all whitespace characters from a string | `deleteSpaces("Hello World"); // "HelloWorld"` |
 | escapeHtml | `(str: string) => string` | Escapes HTML special characters in a string | `escapeHtml("<script>alert('XSS')</script>"); // "&lt;script&gt;alert(&#39;XSS&#39;)&lt;/script&gt;"` |
 | formatString | `(template: string, ...values: unknown[]) => string` | Replaces placeholders in a template string with specified values | `formatString("Hello, {0}!", "World"); // "Hello, World!"` |
+| fuzzySearch | `(query: string, items: string[], threshold?: number) => Array<{ item: string; score: number }>` | Perform fuzzy string matching on an array of strings | `fuzzySearch("hello", ["hello", "world", "helo", "help"]); // [{ item: "hello", score: 1 }, { item: "helo", score: 0.8 }, { item: "help", score: 0.6 }]` |
 | fromBase64 | `(base64String: string) => string` | Converts Base64 to string | `fromBase64("SGVsbG8="); // "Hello"` |
 | hasNoLetters | `(text: string) => boolean` | Checks if the string contains no letters (contains only emojis, numbers, or special characters) | `hasNoLetters("123"); // true` |
 | kebabCase | `(str: string) => string` | Converts a string to kebab-case | `kebabCase("helloWorld"); // "hello-world"` |
@@ -201,12 +222,15 @@ bun add umt
 | randomString | `(size?: number, char?: string) => string` | Generates a random string | `randomString(8); // "aB3dEf9h"` |
 | randomStringInitialization | `(char?: string) => (size: number) => string` | Initializes a function that generates random strings | `const gen = randomStringInitialization("ABC"); gen(5); // "ABCAB"` |
 | reverseString | `(char: string) => string` | Reverses a string | `reverseString("Hello"); // "olleH"` |
+| slugify | `(str: string) => string` | Convert a string to a URL-friendly slug | `slugify("Hello World!"); // "hello-world"` |
 | stringSimilarity | `(string1: string, string2: string) => number` | Calculates the similarity between two strings as a percentage (0-1) using Levenshtein distance | `stringSimilarity("hello", "hallo"); // 0.8` |
 | toBase64 | `(char: string) => string` | Convert string to Base64 | `toBase64("Hello"); // "SGVsbG8="` |
 | toHalfWidth | `(str: string) => string` | Convert full-width characters to half-width characters | `toHalfWidth("１２３ＡＢＣ"); // "123ABC"` |
 | trimCharacters | `(string_: string, chars: string) => string` | Removes specified characters from both ends of a string | `trimCharacters("!!!hello!!!", "!"); // "hello"` |
 | trimEndCharacters | `(string_: string, chars: string) => string` | Removes specified characters from the end of a string | `trimEndCharacters("hello!!!", "!"); // "hello"` |
 | trimStartCharacters | `(string_: string, chars: string) => string` | Removes specified characters from the start of a string | `trimStartCharacters("!!!hello", "!"); // "hello"` |
+| truncate | `(str: string, length: number, suffix?: string) => string` | Truncate a string to a specified length | `truncate("Hello World", 5); // "Hello..."` |
+| unescapeHtml | `(str: string) => string` | Unescapes HTML entities in a string | `unescapeHtml("&lt;script&gt;alert(&quot;Hello&quot;);&lt;/script&gt;"); // "<script>alert("Hello");</script>"` |
 
 ### Time
 
@@ -250,6 +274,7 @@ bun add umt
 | isArray | `<T>(array: unknown) => array is T[]` | Determines if the value is an array | `isArray([1, 2, 3]); // true` |
 | isBrowser | `() => boolean` | Determines if the current environment is a browser | `isBrowser(); // true in browser` |
 | isBun | `() => boolean` | Determines if the current environment is Bun runtime | `isBun(); // true in Bun` |
+| isDeepEqual | `(a: unknown, b: unknown, options?: IsDeepEqualOptions) => boolean` | Performs deep equality comparison between two values with support for nested objects, arrays, Sets, Maps, and circular references | `isDeepEqual({ a: 1, b: [2, 3] }, { b: [2, 3], a: 1 }); // true` |
 | isDictionaryObject | `<T extends { [key: string]: unknown }>(object: unknown) => object is T` | Determines if the value is a dictionary-type object | `isDictionaryObject({}); // true` |
 | isDouble | `<T extends boolean = true>(x: unknown, loose?: T) => x is T extends true ? number \| string : number` | Determines if the value is a decimal number | `isDouble(0.1); // true` |
 | isEqual | `(a: unknown, b: unknown) => boolean` | Evaluates true strict equality | `isEqual(1, 1); // true` |

package/module/Crypto/decodeBase32.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Decodes a Base32 string to Uint8Array
+ * @param {string} input - Base32 encoded string
+ * @returns {Uint8Array} Decoded bytes
+ * @example decodeBase32("JBSWY3DP"); // Uint8Array for "Hello"
+ */
+export declare const decodeBase32: (input: string) => Uint8Array;

package/module/Crypto/decodeBase32.js

@@ -0,0 +1,27 @@
+/**
+ * Decodes a Base32 string to Uint8Array
+ * @param {string} input - Base32 encoded string
+ * @returns {Uint8Array} Decoded bytes
+ * @example decodeBase32("JBSWY3DP"); // Uint8Array for "Hello"
+ */
+export const decodeBase32 = (input) => {
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    const cleanedInput = input.replaceAll("=", "");
+    const result = [];
+    let buffer = 0;
+    let bufferLength = 0;
+    for (const char of cleanedInput) {
+        const value = alphabet.indexOf(char);
+        if (value === -1) {
+            throw new Error(`Invalid base32 character: ${char}`);
+        }
+        buffer = (buffer << 5) | value;
+        bufferLength += 5;
+        if (bufferLength >= 8) {
+            bufferLength -= 8;
+            result.push((buffer >> bufferLength) & 0xff);
+        }
+    }
+    return new Uint8Array(result);
+};
+//# sourceMappingURL=decodeBase32.js.map

package/module/Crypto/decodeBase32.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeBase32.js","sourceRoot":"","sources":["../../src/Crypto/decodeBase32.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAa,EAAc,EAAE;IACxD,MAAM,QAAQ,GAAG,kCAAkC,CAAC;IACpD,MAAM,YAAY,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAC/C,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,YAAY,GAAG,CAAC,CAAC;IAErB,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QAChC,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,6BAA6B,IAAI,EAAE,CAAC,CAAC;QACvD,CAAC;QAED,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC;QAC/B,YAAY,IAAI,CAAC,CAAC;QAElB,IAAI,YAAY,IAAI,CAAC,EAAE,CAAC;YACtB,YAAY,IAAI,CAAC,CAAC;YAClB,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,IAAI,YAAY,CAAC,GAAG,IAAI,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IAED,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;AAChC,CAAC,CAAC"}

package/module/Crypto/decodeBase32ToString.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Decodes a Base32 string to a UTF-8 string
+ * @param {string} input - Base32 encoded string
+ * @returns {string} Decoded string
+ * @example decodeBase32ToString("JBSWY3DP"); // "Hello"
+ */
+export declare const decodeBase32ToString: (input: string) => string;

package/module/Crypto/decodeBase32ToString.js

@@ -0,0 +1,11 @@
+import { decodeBase32 } from "./decodeBase32";
+/**
+ * Decodes a Base32 string to a UTF-8 string
+ * @param {string} input - Base32 encoded string
+ * @returns {string} Decoded string
+ * @example decodeBase32ToString("JBSWY3DP"); // "Hello"
+ */
+export const decodeBase32ToString = (input) => {
+    return new TextDecoder().decode(decodeBase32(input));
+};
+//# sourceMappingURL=decodeBase32ToString.js.map

package/module/Crypto/decodeBase32ToString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeBase32ToString.js","sourceRoot":"","sources":["../../src/Crypto/decodeBase32ToString.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,KAAa,EAAU,EAAE;IAC5D,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;AACvD,CAAC,CAAC"}

package/module/Crypto/decodeBase58.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Decodes a Base58 string to Uint8Array
+ * @param {string} input - Base58 encoded string
+ * @returns {Uint8Array} Decoded bytes
+ * @example decodeBase58("9Ajdvzr"); // Uint8Array for "Hello"
+ */
+export declare const decodeBase58: (input: string) => Uint8Array;

package/module/Crypto/decodeBase58.js

@@ -0,0 +1,34 @@
+/**
+ * Decodes a Base58 string to Uint8Array
+ * @param {string} input - Base58 encoded string
+ * @returns {Uint8Array} Decoded bytes
+ * @example decodeBase58("9Ajdvzr"); // Uint8Array for "Hello"
+ */
+export const decodeBase58 = (input) => {
+    const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let bigNumber = BigInt(0);
+    for (const char of input) {
+        const value = alphabet.indexOf(char);
+        if (value === -1) {
+            throw new Error(`Invalid base58 character: ${char}`);
+        }
+        bigNumber = bigNumber * BigInt(58) + BigInt(value);
+    }
+    const bytes = [];
+    while (bigNumber > 0) {
+        bytes.unshift(Number(bigNumber % BigInt(256)));
+        bigNumber /= BigInt(256);
+    }
+    let leadingOnes = 0;
+    for (const char of input) {
+        if (char !== "1") {
+            break;
+        }
+        leadingOnes++;
+    }
+    return new Uint8Array([
+        ...Array.from({ length: leadingOnes }).fill(0),
+        ...bytes,
+    ]);
+};
+//# sourceMappingURL=decodeBase58.js.map

package/module/Crypto/decodeBase58.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeBase58.js","sourceRoot":"","sources":["../../src/Crypto/decodeBase58.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAa,EAAc,EAAE;IACxD,MAAM,QAAQ,GAAG,4DAA4D,CAAC;IAC9E,IAAI,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAE1B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,6BAA6B,IAAI,EAAE,CAAC,CAAC;QACvD,CAAC;QACD,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IACrD,CAAC;IAED,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,OAAO,SAAS,GAAG,CAAC,EAAE,CAAC;QACrB,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC/C,SAAS,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,MAAM;QACR,CAAC;QACD,WAAW,EAAE,CAAC;IAChB,CAAC;IAED,OAAO,IAAI,UAAU,CAAC;QACpB,GAAI,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAc;QAC5D,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC,CAAC"}

package/module/Crypto/decodeBase58ToString.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Decodes a Base58 string to a UTF-8 string
+ * @param {string} input - Base58 encoded string
+ * @returns {string} Decoded string
+ * @example decodeBase58ToString("9Ajdvzr"); // "Hello"
+ */
+export declare const decodeBase58ToString: (input: string) => string;

package/module/Crypto/decodeBase58ToString.js

@@ -0,0 +1,11 @@
+import { decodeBase58 } from "./decodeBase58";
+/**
+ * Decodes a Base58 string to a UTF-8 string
+ * @param {string} input - Base58 encoded string
+ * @returns {string} Decoded string
+ * @example decodeBase58ToString("9Ajdvzr"); // "Hello"
+ */
+export const decodeBase58ToString = (input) => {
+    return new TextDecoder().decode(decodeBase58(input));
+};
+//# sourceMappingURL=decodeBase58ToString.js.map

package/module/Crypto/decodeBase58ToString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeBase58ToString.js","sourceRoot":"","sources":["../../src/Crypto/decodeBase58ToString.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,KAAa,EAAU,EAAE;IAC5D,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;AACvD,CAAC,CAAC"}

package/module/Crypto/encodeBase32.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Encodes a string or Uint8Array to Base32 format
+ * @param {string | Uint8Array} input - The input to encode
+ * @returns {string} Base32 encoded string
+ * @example encodeBase32("Hello"); // "JBSWY3DP"
+ */
+export declare const encodeBase32: (input: string | Uint8Array) => string;

package/module/Crypto/encodeBase32.js

@@ -0,0 +1,28 @@
+/**
+ * Encodes a string or Uint8Array to Base32 format
+ * @param {string | Uint8Array} input - The input to encode
+ * @returns {string} Base32 encoded string
+ * @example encodeBase32("Hello"); // "JBSWY3DP"
+ */
+export const encodeBase32 = (input) => {
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+    let result = "";
+    let buffer = 0;
+    let bufferLength = 0;
+    for (const byte of bytes) {
+        buffer = (buffer << 8) | byte;
+        bufferLength += 8;
+        while (bufferLength >= 5) {
+            bufferLength -= 5;
+            result += alphabet[(buffer >> bufferLength) & 0x1f];
+        }
+    }
+    if (bufferLength > 0) {
+        result += alphabet[(buffer << (5 - bufferLength)) & 0x1f];
+    }
+    const paddingLength = (8 - (result.length % 8)) % 8;
+    result += "=".repeat(paddingLength);
+    return result;
+};
+//# sourceMappingURL=encodeBase32.js.map

package/module/Crypto/encodeBase32.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeBase32.js","sourceRoot":"","sources":["../../src/Crypto/encodeBase32.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAA0B,EAAU,EAAE;IACjE,MAAM,QAAQ,GAAG,kCAAkC,CAAC;IACpD,MAAM,KAAK,GACT,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAEtE,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,YAAY,GAAG,CAAC,CAAC;IAErB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;QAC9B,YAAY,IAAI,CAAC,CAAC;QAElB,OAAO,YAAY,IAAI,CAAC,EAAE,CAAC;YACzB,YAAY,IAAI,CAAC,CAAC;YAClB,MAAM,IAAI,QAAQ,CAAC,CAAC,MAAM,IAAI,YAAY,CAAC,GAAG,IAAI,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IAED,IAAI,YAAY,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,QAAQ,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAC5D,CAAC;IAED,MAAM,aAAa,GAAG,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACpD,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IAEpC,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}

package/module/Crypto/encodeBase58.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Encodes a string or Uint8Array to Base58 format
+ * @param {string | Uint8Array} input - The input to encode
+ * @returns {string} Base58 encoded string
+ * @example encodeBase58("Hello"); // "9Ajdvzr"
+ */
+export declare const encodeBase58: (input: string | Uint8Array) => string;

package/module/Crypto/encodeBase58.js

@@ -0,0 +1,29 @@
+/**
+ * Encodes a string or Uint8Array to Base58 format
+ * @param {string | Uint8Array} input - The input to encode
+ * @returns {string} Base58 encoded string
+ * @example encodeBase58("Hello"); // "9Ajdvzr"
+ */
+export const encodeBase58 = (input) => {
+    const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+    let encoded = "";
+    let bigNumber = BigInt(0);
+    for (const byte of bytes) {
+        bigNumber = bigNumber * BigInt(256) + BigInt(byte);
+    }
+    while (bigNumber > 0) {
+        const remainder = Number(bigNumber % BigInt(58));
+        encoded = alphabet[remainder] + encoded;
+        bigNumber /= BigInt(58);
+    }
+    let leadingZeros = 0;
+    for (const byte of bytes) {
+        if (byte !== 0) {
+            break;
+        }
+        leadingZeros++;
+    }
+    return "1".repeat(leadingZeros) + encoded;
+};
+//# sourceMappingURL=encodeBase58.js.map

package/module/Crypto/encodeBase58.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeBase58.js","sourceRoot":"","sources":["../../src/Crypto/encodeBase58.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAA0B,EAAU,EAAE;IACjE,MAAM,QAAQ,GAAG,4DAA4D,CAAC;IAC9E,MAAM,KAAK,GACT,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAEtE,IAAI,OAAO,GAAG,EAAE,CAAC;IACjB,IAAI,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAE1B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IACrD,CAAC;IAED,OAAO,SAAS,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;QACjD,OAAO,GAAG,QAAQ,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;QACxC,SAAS,IAAI,MAAM,CAAC,EAAE,CAAC,CAAC;IAC1B,CAAC;IAED,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;YACf,MAAM;QACR,CAAC;QACD,YAAY,EAAE,CAAC;IACjB,CAAC;IAED,OAAO,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC;AAC5C,CAAC,CAAC"}

package/module/Crypto/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./decodeBase32";
+export * from "./decodeBase32ToString";
+export * from "./decodeBase58";
+export * from "./decodeBase58ToString";
+export * from "./encodeBase32";
+export * from "./encodeBase58";

package/module/Crypto/index.js

@@ -0,0 +1,7 @@
+export * from "./decodeBase32";
+export * from "./decodeBase32ToString";
+export * from "./decodeBase58";
+export * from "./decodeBase58ToString";
+export * from "./encodeBase32";
+export * from "./encodeBase58";
+//# sourceMappingURL=index.js.map

package/module/Crypto/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Crypto/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC"}

package/module/DataStructure/index.d.ts

@@ -0,0 +1 @@
+export * from "./priorityQueue";

package/module/DataStructure/index.js

@@ -0,0 +1,2 @@
+export * from "./priorityQueue";
+//# sourceMappingURL=index.js.map

package/module/DataStructure/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/DataStructure/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/module/DataStructure/priorityQueue.d.ts

@@ -0,0 +1,241 @@
+/**
+ * A priority queue implementation using a binary heap.
+ * Higher priority values are dequeued first.
+ *
+ * ## Features
+ * - **enqueue(value, priority)**: Add element with priority
+ * - **enqueueBack(value)**: Add element to the back with lowest priority
+ * - **dequeue()**: Remove and return highest priority element
+ * - **peek()**: View highest priority element without removing
+ * - **peekPriority()**: View highest priority value
+ * - **size**: Get number of elements
+ * - **isEmpty**: Check if queue is empty
+ * - **clear()**: Remove all elements
+ * - **toArray()**: Get all elements as array
+ * - **toArrayWithPriorities()**: Get all elements with priorities
+ *
+ * ## Time Complexity
+ * - enqueue: O(log n)
+ * - enqueueBack: O(log n)
+ * - dequeue: O(log n)
+ * - peek: O(1)
+ * - peekPriority: O(1)
+ *
+ * @example
+ * ```typescript
+ * const queue = new PriorityQueue<string>();
+ * queue.enqueue("low", 1);
+ * queue.enqueue("high", 3);
+ * queue.enqueue("medium", 2);
+ *
+ * console.log(queue.dequeue()); // "high"
+ * console.log(queue.dequeue()); // "medium"
+ * console.log(queue.dequeue()); // "low"
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Initialize with elements
+ * const queue = new PriorityQueue([
+ *   { value: "task1", priority: 1 },
+ *   { value: "task2", priority: 3 },
+ *   { value: "task3", priority: 2 }
+ * ]);
+ *
+ * console.log(queue.peek()); // "task2"
+ * console.log(queue.peekPriority()); // 3
+ * ```
+ *
+ * @template T - The type of elements stored in the queue
+ */
+export declare class PriorityQueue<T> {
+    private heap;
+    private minPriority;
+    /**
+     * Creates a new PriorityQueue instance.
+     * @param initialElements - Optional array of initial elements with priorities
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * // or
+     * const queue = new PriorityQueue([
+     *   { value: "item1", priority: 10 },
+     *   { value: "item2", priority: 5 }
+     * ]);
+     * ```
+     */
+    constructor(initialElements?: Array<{
+        value: T;
+        priority: number;
+    }>);
+    /**
+     * Returns the number of elements in the queue.
+     * @returns The number of elements in the queue
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * queue.enqueue("item", 1);
+     * console.log(queue.size); // 1
+     * ```
+     */
+    get size(): number;
+    /**
+     * Checks if the queue is empty.
+     * @returns True if the queue is empty, false otherwise
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * console.log(queue.isEmpty); // true
+     * queue.enqueue("item", 1);
+     * console.log(queue.isEmpty); // false
+     * ```
+     */
+    get isEmpty(): boolean;
+    /**
+     * Adds an element to the queue with a specified priority.
+     * Higher priority values are dequeued first.
+     * @param value - The value to add
+     * @param priority - The priority value (higher values have higher priority)
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * queue.enqueue("low", 1);
+     * queue.enqueue("high", 10);
+     * queue.enqueue("medium", 5);
+     * console.log(queue.dequeue()); // "high"
+     * ```
+     */
+    enqueue(value: T, priority: number): void;
+    /**
+     * Adds an element to the end of the queue with lowest priority.
+     * This element will be dequeued last (FIFO for equal lowest priority).
+     *
+     * @param value - The value to add
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * queue.enqueue("high", 10);
+     * queue.enqueue("medium", 5);
+     * queue.enqueueBack("back1");
+     * queue.enqueueBack("back2");
+     * console.log(queue.dequeue()); // "high"
+     * console.log(queue.dequeue()); // "medium"
+     * console.log(queue.dequeue()); // "back1"
+     * console.log(queue.dequeue()); // "back2"
+     * ```
+     */
+    enqueueBack(value: T): void;
+    /**
+     * Removes and returns the element with the highest priority.
+     * @returns The element with highest priority, or undefined if queue is empty
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * queue.enqueue("low", 1);
+     * queue.enqueue("high", 10);
+     * console.log(queue.dequeue()); // "high"
+     * console.log(queue.dequeue()); // "low"
+     * console.log(queue.dequeue()); // undefined
+     * ```
+     */
+    dequeue(): T | undefined;
+    /**
+     * Returns the element with the highest priority without removing it.
+     * @returns The element with highest priority, or undefined if queue is empty
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * queue.enqueue("low", 1);
+     * queue.enqueue("high", 10);
+     * console.log(queue.peek()); // "high"
+     * console.log(queue.size); // 2 (element not removed)
+     * ```
+     */
+    peek(): T | undefined;
+    /**
+     * Returns the priority of the element with the highest priority.
+     * @returns The highest priority value, or undefined if queue is empty
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * queue.enqueue("low", 1);
+     * queue.enqueue("high", 10);
+     * console.log(queue.peekPriority()); // 10
+     * ```
+     */
+    peekPriority(): number | undefined;
+    /**
+     * Removes all elements from the queue.
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * queue.enqueue("item1", 1);
+     * queue.enqueue("item2", 2);
+     * console.log(queue.size); // 2
+     * queue.clear();
+     * console.log(queue.size); // 0
+     * console.log(queue.isEmpty); // true
+     * ```
+     */
+    clear(): void;
+    /**
+     * Returns an array of all elements in the queue (without removing them).
+     * The order is not guaranteed to be sorted by priority.
+     * @returns Array of all elements in the queue
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * queue.enqueue("low", 1);
+     * queue.enqueue("high", 10);
+     * queue.enqueue("medium", 5);
+     * console.log(queue.toArray()); // ["high", "medium", "low"] (order may vary)
+     * ```
+     */
+    toArray(): T[];
+    /**
+     * Returns an array of all elements with their priorities.
+     * The order is not guaranteed to be sorted by priority.
+     * @returns Array of all elements with their priorities
+     * @example
+     * ```typescript
+     * const queue = new PriorityQueue<string>();
+     * queue.enqueue("low", 1);
+     * queue.enqueue("high", 10);
+     * console.log(queue.toArrayWithPriorities());
+     * // [{ value: "high", priority: 10 }, { value: "low", priority: 1 }] (order may vary)
+     * ```
+     */
+    toArrayWithPriorities(): Array<{
+        value: T;
+        priority: number;
+    }>;
+    /**
+     * Updates the minimum priority when adding elements.
+     * @param priority - The priority being added
+     */
+    private updateMinPriorityOnAdd;
+    /**
+     * Updates the minimum priority from all elements (used in constructor).
+     */
+    private updateMinPriority;
+    /**
+     * Builds a max heap from the current heap array.
+     */
+    private buildHeap;
+    /**
+     * Moves an element up the heap to maintain heap property.
+     * @param index - The index of the element to move up
+     */
+    private heapifyUp;
+    /**
+     * Moves an element down the heap to maintain heap property.
+     * @param index - The index of the element to move down
+     */
+    private heapifyDown;
+    /**
+     * Swaps two elements in the heap.
+     * @param i - First index
+     * @param j - Second index
+     */
+    private swap;
+}