stringzy 2.2.1 → 4.0.0

package/dist/analyzing/stringSimilarity.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringSimilarity = stringSimilarity;
+/**
+ * Calculates the percentage similarity between two texts using the selected algorithm.
+ * @param textA The first text to compare.
+ * @param textB The second text to compare.
+ * @param algorithm The algorithm to use: 'Levenshtein' or 'Damerau-Levenshtein'. Default is 'Levenshtein'.
+ * @returns Similarity percentage (0-100).
+ */
+function stringSimilarity(textA, textB, algorithm = 'Levenshtein') {
+    validateParams(textA, textB, algorithm);
+    if (textA === textB) {
+        return 100.0;
+    }
+    if (textA.length === 0 && textB.length != 0) {
+        return 0.0;
+    }
+    let distance;
+    if (algorithm === 'Levenshtein') {
+        distance = calculateLevenshteinDistance(textA, textB);
+    }
+    else {
+        distance = calculateDamerauLevenshteinDistance(textA, textB);
+    }
+    return calculateSimilarityScore(distance, textA, textB);
+}
+/**
+ * Converts the edit distance to a percentage similarity score.
+ * @param distance The edit distance between the texts.
+ * @param textA The first text.
+ * @param textB The second text.
+ * @returns Similarity percentage (0-100).
+ */
+function calculateSimilarityScore(distance, textA, textB) {
+    const similarityScore = 1 - distance / Math.max(textA.length, textB.length);
+    return parseFloat((similarityScore * 100).toFixed(2));
+}
+/**
+ * Calculates the Levenshtein distance between two texts.
+ * @param textA The first text.
+ * @param textB The second text.
+ * @returns The Levenshtein distance.
+ */
+function calculateLevenshteinDistance(textA, textB) {
+    const lenA = textA.length;
+    const lenB = textB.length;
+    if (lenA === 0) {
+        return lenB;
+    }
+    if (lenB === 0) {
+        return lenA;
+    }
+    const distancesMatrix = prepareDistanceMatrix(lenA, lenB);
+    for (let i = 1; i <= lenA; i++) {
+        for (let j = 1; j <= lenB; j++) {
+            distancesMatrix[i][j] = applyBasicEditOperations(i, j, textA, textB, distancesMatrix);
+        }
+    }
+    return distancesMatrix[lenA][lenB];
+}
+/**
+ * Calculates the Damerau-Levenshtein distance between two texts.
+ * @param textA The first text.
+ * @param textB The second text.
+ * @returns The Damerau-Levenshtein distance.
+ */
+function calculateDamerauLevenshteinDistance(textA, textB) {
+    const lenA = textA.length;
+    const lenB = textB.length;
+    if (lenA === 0) {
+        return lenB;
+    }
+    if (lenB === 0) {
+        return lenA;
+    }
+    const distancesMatrix = prepareDistanceMatrix(lenA, lenB);
+    for (let i = 1; i <= lenA; i++) {
+        for (let j = 1; j <= lenB; j++) {
+            distancesMatrix[i][j] = applyBasicEditOperations(i, j, textA, textB, distancesMatrix);
+            if (i > 1 && j > 1 && textA[i - 1] === textB[j - 2] && textA[i - 2] === textB[j - 1]) {
+                distancesMatrix[i][j] = Math.min(distancesMatrix[i][j], distancesMatrix[i - 2][j - 2] + 1);
+            }
+        }
+    }
+    return distancesMatrix[lenA][lenB];
+}
+/**
+ * Prepares a distance matrix for edit distance calculations.
+ * @param lenA Length of the first text.
+ * @param lenB Length of the second text.
+ * @returns A 2D array representing the distance matrix.
+ */
+function prepareDistanceMatrix(lenA, lenB) {
+    const distancesMatrix = Array.from({ length: lenA + 1 }, () => Array(lenB + 1).fill(0));
+    for (let i = 0; i <= lenA; i++) {
+        distancesMatrix[i][0] = i;
+    }
+    for (let j = 0; j <= lenB; j++) {
+        distancesMatrix[0][j] = j;
+    }
+    return distancesMatrix;
+}
+/**
+ * Applies basic edit operations (deletion, insertion, substitution) for edit distance algorithms.
+ * @param i Current row index in the matrix.
+ * @param j Current column index in the matrix.
+ * @param textA The first text.
+ * @param textB The second text.
+ * @param matrix The distance matrix.
+ * @returns The minimum cost for the current cell.
+ */
+function applyBasicEditOperations(i, j, textA, textB, matrix) {
+    const cost = textA[i - 1] === textB[j - 1] ? 0 : 1;
+    return Math.min(matrix[i - 1][j] + 1, // Deletion
+    matrix[i][j - 1] + 1, // Insertion
+    matrix[i - 1][j - 1] + cost // Substitution
+    );
+}
+/////////////////////////////////////////
+//// Validation Functions
+/////////////////////////////////////////
+/**
+ * Checks if a value is a string.
+ * @param value The value to check.
+ * @returns True if the value is a string, otherwise false.
+ */
+function isString(value) {
+    return typeof value === 'string';
+}
+/**
+ * Validates the input parameters for the string similarity functions.
+ * @param textA The first text.
+ * @param textB The second text.
+ * @param algorithm The algorithm to use.
+ * @throws Error if parameters are invalid.
+ */
+function validateParams(textA, textB, algorithm) {
+    if (!isString(textA) || !isString(textB)) {
+        throw new Error('Both text arguments must be strings');
+    }
+    if (algorithm !== 'Levenshtein' && algorithm !== 'Damerau-Levenshtein') {
+        throw new Error("Invalid optional algorithm param. Should be 'Levenshtein' or 'Damerau-Levenshtein'");
+    }
+}

package/dist/analyzing/vowelConsonantCount.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns the number of vowels and consonants in a given string.
+ *
+ * This function counts the number of vowels and consonants in the string, ignoring whitespace,
+ * punctuation, and special characters. It throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The string whose vowels and consonants will be counted.
+ * @returns {{ vowels: number, consonants: number }} An object containing the counts of vowels and consonants.
+ * @throws {TypeError} If the input is not of type string
+ *
+ * @example
+ * vowelConsonantCount("hello");
+ * // { vowels: 2, consonants: 3 }
+ *
+ * @example
+ * vowelConsonantCount("stringzy");
+ * // { vowels: 1, consonants: 7 }
+ */
+export declare function vowelConsonantCount(str: string): {
+    vowels: number;
+    consonants: number;
+};

package/dist/analyzing/vowelConsonantCount.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vowelConsonantCount = vowelConsonantCount;
+/**
+ * Returns the number of vowels and consonants in a given string.
+ *
+ * This function counts the number of vowels and consonants in the string, ignoring whitespace,
+ * punctuation, and special characters. It throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The string whose vowels and consonants will be counted.
+ * @returns {{ vowels: number, consonants: number }} An object containing the counts of vowels and consonants.
+ * @throws {TypeError} If the input is not of type string
+ *
+ * @example
+ * vowelConsonantCount("hello");
+ * // { vowels: 2, consonants: 3 }
+ *
+ * @example
+ * vowelConsonantCount("stringzy");
+ * // { vowels: 1, consonants: 7 }
+ */
+function vowelConsonantCount(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    const vowels = 'aeiouAEIOU';
+    let vowelCount = 0;
+    let consonantCount = 0;
+    for (const char of str) {
+        if (vowels.includes(char)) {
+            vowelCount++;
+        }
+        else if (char.toLowerCase() >= 'a' && char.toLowerCase() <= 'z') {
+            consonantCount++;
+        }
+    }
+    return { vowels: vowelCount, consonants: consonantCount };
+}

package/dist/analyzing/wordCount.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Counts the number of words in a given string.
+ *
+ * Words are defined as sequences of non-whitespace characters separated by one or more
+ * whitespace characters (spaces, tabs, newlines, etc.). Leading and trailing whitespace
+ * is trimmed before counting.
+ *
+ * Throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The string to analyze.
+ * @returns {number} The number of words in the input string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * wordCount("Hello world"); // 2
+ *
+ * @example
+ * wordCount("  This  is   a test\nwith multiple lines "); // 7
+ *
+ * @example
+ * wordCount("     "); // 0
+ */
+export declare function wordCount(str: string): number;

package/dist/analyzing/wordCount.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordCount = wordCount;
+/**
+ * Counts the number of words in a given string.
+ *
+ * Words are defined as sequences of non-whitespace characters separated by one or more
+ * whitespace characters (spaces, tabs, newlines, etc.). Leading and trailing whitespace
+ * is trimmed before counting.
+ *
+ * Throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The string to analyze.
+ * @returns {number} The number of words in the input string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * wordCount("Hello world"); // 2
+ *
+ * @example
+ * wordCount("  This  is   a test\nwith multiple lines "); // 7
+ *
+ * @example
+ * wordCount("     "); // 0
+ */
+function wordCount(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (!str.trim())
+        return 0;
+    return str.trim().split(/\s+/).length;
+}

package/dist/formatting/capitalize.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Capitalizes the first letter of each word in a string.
+ *
+ * Converts the first character of each word to uppercase and the remaining characters to lowercase.
+ * Words are assumed to be separated by spaces. Handles multiple words and mixed casing.
+ *
+ * Throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The input string to capitalize.
+ * @returns {string} A new string with each word capitalized.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * capitalize("hello world"); // "Hello World"
+ *
+ * @example
+ * capitalize("mIxEd CaSe tExT"); // "Mixed Case Text"
+ *
+ * @example
+ * capitalize("  multiple   spaces "); // "Multiple Spaces"
+ */
+export declare function capitalize(str: string): string;

package/dist/formatting/capitalize.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalize = capitalize;
+/**
+ * Capitalizes the first letter of each word in a string.
+ *
+ * Converts the first character of each word to uppercase and the remaining characters to lowercase.
+ * Words are assumed to be separated by spaces. Handles multiple words and mixed casing.
+ *
+ * Throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The input string to capitalize.
+ * @returns {string} A new string with each word capitalized.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * capitalize("hello world"); // "Hello World"
+ *
+ * @example
+ * capitalize("mIxEd CaSe tExT"); // "Mixed Case Text"
+ *
+ * @example
+ * capitalize("  multiple   spaces "); // "Multiple Spaces"
+ */
+function capitalize(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    return str
+        .split(' ')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(' ');
+}

package/dist/formatting/index.d.ts

@@ -0,0 +1,11 @@
+export { capitalize } from './capitalize';
+export { formatNumber } from './number';
+export { formatPhone } from './phone';
+import { capitalize } from './capitalize';
+import { formatNumber } from './number';
+import { formatPhone } from './phone';
+export declare const formatting: {
+    capitalize: typeof capitalize;
+    formatNumber: typeof formatNumber;
+    formatPhone: typeof formatPhone;
+};

package/dist/formatting/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatting = exports.formatPhone = exports.formatNumber = exports.capitalize = void 0;
+var capitalize_1 = require("./capitalize");
+Object.defineProperty(exports, "capitalize", { enumerable: true, get: function () { return capitalize_1.capitalize; } });
+var number_1 = require("./number");
+Object.defineProperty(exports, "formatNumber", { enumerable: true, get: function () { return number_1.formatNumber; } });
+var phone_1 = require("./phone");
+Object.defineProperty(exports, "formatPhone", { enumerable: true, get: function () { return phone_1.formatPhone; } });
+const capitalize_2 = require("./capitalize");
+const number_2 = require("./number");
+const phone_2 = require("./phone");
+exports.formatting = {
+    capitalize: capitalize_2.capitalize,
+    formatNumber: number_2.formatNumber,
+    formatPhone: phone_2.formatPhone,
+};

package/dist/formatting/number.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Formats a number with a thousands separator.
+ *
+ * Converts a number or numeric string into a more readable format by inserting the specified
+ * thousands separator (either `','` or `'.'`). This function does not round or localize
+ * decimals — it only adds the separator between every three digits from the right.
+ *
+ * The input is first converted to a string before formatting. If the input is not a valid
+ * number or numeric string, the output may be incorrect.
+ *
+ * @param {string | number} num - The number or numeric string to format.
+ * @param {'.' | ','} [thousendsSeperator=','] - The character to use as the thousands separator.
+ * @returns {string} The formatted string with the separator added.
+ *
+ * @example
+ * formatNumber(1234567); // "1,234,567"
+ *
+ * @example
+ * formatNumber("987654321", '.'); // "987.654.321"
+ *
+ * @example
+ * formatNumber(12345.67); // "12,345.67" (decimals preserved as-is)
+ */
+export declare function formatNumber(num: string | number, thousendsSeperator?: '.' | ','): string;

package/dist/formatting/number.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatNumber = formatNumber;
+/**
+ * Formats a number with a thousands separator.
+ *
+ * Converts a number or numeric string into a more readable format by inserting the specified
+ * thousands separator (either `','` or `'.'`). This function does not round or localize
+ * decimals — it only adds the separator between every three digits from the right.
+ *
+ * The input is first converted to a string before formatting. If the input is not a valid
+ * number or numeric string, the output may be incorrect.
+ *
+ * @param {string | number} num - The number or numeric string to format.
+ * @param {'.' | ','} [thousendsSeperator=','] - The character to use as the thousands separator.
+ * @returns {string} The formatted string with the separator added.
+ *
+ * @example
+ * formatNumber(1234567); // "1,234,567"
+ *
+ * @example
+ * formatNumber("987654321", '.'); // "987.654.321"
+ *
+ * @example
+ * formatNumber(12345.67); // "12,345.67" (decimals preserved as-is)
+ */
+function formatNumber(num, thousendsSeperator = ',') {
+    const numStr = num.toString();
+    return numStr.replace(/\B(?=(\d{3})+(?!\d))/g, thousendsSeperator);
+}

package/dist/formatting/phone.d.ts

@@ -0,0 +1,25 @@
+export type PhoneFormat = 'us' | 'in' | 'international';
+/**
+ * Formats a phone number string into a readable format based on the given region.
+ *
+ * Strips all non-digit characters before formatting. Supports formatting for:
+ * - `'us'`: U.S. numbers with 10 digits → `(123) 456-7890`
+ * - `'in'`: Indian numbers with 10 digits or 12 digits starting with '91' → `+91-12345-67890`
+ * - `'international'`: Generic international format assuming last 10 digits are the local number.
+ *
+ * If the number does not match expected formats, it returns the original input.
+ *
+ * @param {string} phone - The phone number string to format.
+ * @param {PhoneFormat} [format='us'] - The desired formatting style: `'us'`, `'in'`, or `'international'`.
+ * @returns {string} The formatted phone number, or the original input if formatting fails.
+ *
+ * @example
+ * formatPhone("1234567890"); // "(123) 456-7890"
+ *
+ * @example
+ * formatPhone("+91 9876543210", "in"); // "+91-98765-43210"
+ *
+ * @example
+ * formatPhone("009199876543210", "international"); // "+0091 (998) 765-43210"
+ */
+export declare function formatPhone(phone: string, format?: PhoneFormat): string;

package/dist/formatting/phone.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPhone = formatPhone;
+/**
+ * Formats a phone number string into a readable format based on the given region.
+ *
+ * Strips all non-digit characters before formatting. Supports formatting for:
+ * - `'us'`: U.S. numbers with 10 digits → `(123) 456-7890`
+ * - `'in'`: Indian numbers with 10 digits or 12 digits starting with '91' → `+91-12345-67890`
+ * - `'international'`: Generic international format assuming last 10 digits are the local number.
+ *
+ * If the number does not match expected formats, it returns the original input.
+ *
+ * @param {string} phone - The phone number string to format.
+ * @param {PhoneFormat} [format='us'] - The desired formatting style: `'us'`, `'in'`, or `'international'`.
+ * @returns {string} The formatted phone number, or the original input if formatting fails.
+ *
+ * @example
+ * formatPhone("1234567890"); // "(123) 456-7890"
+ *
+ * @example
+ * formatPhone("+91 9876543210", "in"); // "+91-98765-43210"
+ *
+ * @example
+ * formatPhone("009199876543210", "international"); // "+0091 (998) 765-43210"
+ */
+function formatPhone(phone, format = 'us') {
+    const digits = phone.replace(/\D/g, '');
+    if (format === 'us' && digits.length === 10) {
+        return `(${digits.slice(0, 3)}) ${digits.slice(3, 6)}-${digits.slice(6)}`;
+    }
+    else if (format === 'international' && digits.length >= 10) {
+        const countryCode = digits.slice(0, -10);
+        const areaCode = digits.slice(-10, -7);
+        const firstPart = digits.slice(-7, -4);
+        const lastPart = digits.slice(-4);
+        return `+${countryCode} (${areaCode}) ${firstPart}-${lastPart}`;
+    }
+    else if (format === 'in') {
+        if (digits.length === 10) {
+            return `+91-${digits.slice(0, 5)}-${digits.slice(5)}`;
+        }
+        else if (digits.length === 12 && digits.startsWith('91')) {
+            return `+91-${digits.slice(2, 7)}-${digits.slice(7)}`;
+        }
+    }
+    return phone;
+}

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+export * from './analyzing';
+export * from './formatting';
+export * from './transformations';
+export * from './validations';
+declare const _default: {
+    analyzing: {
+        characterCount: typeof import("./analyzing").characterCount;
+        characterFrequency: typeof import("./analyzing").characterFrequency;
+        complexity: typeof import("./analyzing").complexity;
+        readingDuration: typeof import("./analyzing").readingDuration;
+        wordCount: typeof import("./analyzing").wordCount;
+        stringSimilarity: typeof import("./analyzing").stringSimilarity;
+        patternCount: typeof import("./analyzing").patternCount;
+        vowelConsonantCount: typeof import("./analyzing").vowelConsonantCount;
+    };
+    formatting: {
+        capitalize: typeof import("./formatting").capitalize;
+        formatNumber: typeof import("./formatting").formatNumber;
+        formatPhone: typeof import("./formatting").formatPhone;
+    };
+    transformations: {
+        camelCase: typeof import("./transformations").camelCase;
+        capitalizeWords: typeof import("./transformations").capitalizeWords;
+        constantCase: typeof import("./transformations").constantCase;
+        initials: typeof import("./transformations").initials;
+        kebabCase: typeof import("./transformations").kebabCase;
+        pascalCase: typeof import("./transformations").pascalCase;
+        removeDuplicates: typeof import("./transformations").removeDuplicates;
+        removeSpecialChars: typeof import("./transformations").removeSpecialChars;
+        removeWords: typeof import("./transformations").removeWords;
+        snakeCase: typeof import("./transformations").snakeCase;
+        titleCase: typeof import("./transformations").titleCase;
+        toSlug: typeof import("./transformations").toSlug;
+        truncateText: typeof import("./transformations").truncateText;
+        escapeHtml: typeof import("./transformations").escapeHtml;
+        maskSegment: typeof import("./transformations").maskSegment;
+        deburr: typeof import("./transformations/deburr").deburr;
+        numberToText: typeof import("./transformations").numberToText;
+    };
+    validations: {
+        isCoordinates: typeof import("./validations").isCoordinates;
+        isDate: typeof import("./validations").isDate;
+        isEmail: typeof import("./validations").isEmail;
+        isEmpty: typeof import("./validations").isEmpty;
+        isSlug: typeof import("./validations").isSlug;
+        isURL: typeof import("./validations").isURL;
+        isIPv4: typeof import("./validations").isIPv4;
+        isHexColor: typeof import("./validations").isHexColor;
+        isPalindrome: typeof import("./validations").isPalindrome;
+    };
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,30 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./analyzing"), exports);
+__exportStar(require("./formatting"), exports);
+__exportStar(require("./transformations"), exports);
+__exportStar(require("./validations"), exports);
+const analyzing_1 = require("./analyzing");
+const formatting_1 = require("./formatting");
+const transformations_1 = require("./transformations");
+const validations_1 = require("./validations");
+exports.default = {
+    analyzing: analyzing_1.analyzing,
+    formatting: formatting_1.formatting,
+    transformations: transformations_1.transformations,
+    validations: validations_1.validations,
+};

package/dist/tests/analyzing/characterCount.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/analyzing/characterCount.test.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const characterCount_1 = require("../../analyzing/characterCount");
+(0, node_test_1.describe)('characterCount', () => {
+    (0, node_test_1.it)('returns length of string', () => {
+        node_assert_1.default.strictEqual((0, characterCount_1.characterCount)('hello'), 5);
+    });
+    (0, node_test_1.it)('returns 0 for empty string', () => {
+        node_assert_1.default.strictEqual((0, characterCount_1.characterCount)(''), 0);
+    });
+    (0, node_test_1.it)('throws if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, characterCount_1.characterCount)(123), /Input must be a string/);
+    });
+});

package/dist/tests/analyzing/characterFrequency.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/analyzing/characterFrequency.test.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const characterFrequency_1 = require("../../analyzing/characterFrequency");
+(0, node_test_1.describe)('characterFrequency', () => {
+    (0, node_test_1.it)('returns frequency of each character', () => {
+        node_assert_1.default.deepStrictEqual((0, characterFrequency_1.characterFrequency)('aab'), { a: 2, b: 1 });
+    });
+    (0, node_test_1.it)('ignores spaces', () => {
+        node_assert_1.default.deepStrictEqual((0, characterFrequency_1.characterFrequency)('a a b'), { a: 2, b: 1 });
+    });
+    (0, node_test_1.it)('returns empty object for empty string', () => {
+        node_assert_1.default.deepStrictEqual((0, characterFrequency_1.characterFrequency)(''), {});
+    });
+    (0, node_test_1.it)('throws if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, characterFrequency_1.characterFrequency)(123), /Input must be a string/);
+    });
+});

package/dist/tests/analyzing/complexity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/analyzing/complexity.test.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const complexity_1 = require("../../analyzing/complexity");
+(0, node_test_1.describe)('complexity', () => {
+    (0, node_test_1.it)('returns 0s for empty string', () => {
+        node_assert_1.default.deepStrictEqual((0, complexity_1.complexity)(''), { score: 0, uniqueness: 0, length: 0 });
+    });
+    (0, node_test_1.it)('returns correct result for simple string', () => {
+        const result = (0, complexity_1.complexity)('abc');
+        node_assert_1.default.strictEqual(typeof result.score, 'number');
+        node_assert_1.default.strictEqual(typeof result.uniqueness, 'number');
+        node_assert_1.default.strictEqual(result.length, 3);
+    });
+    (0, node_test_1.it)('returns correct result for complex string', () => {
+        const result = (0, complexity_1.complexity)('aA1!aA1!');
+        node_assert_1.default.ok(result.score > 0);
+        node_assert_1.default.ok(result.uniqueness > 0);
+        node_assert_1.default.strictEqual(result.length, 8);
+    });
+    (0, node_test_1.it)('throws if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, complexity_1.complexity)(123), /Input must be a string/);
+    });
+});

package/dist/tests/analyzing/patternCount.test.d.ts

@@ -0,0 +1 @@
+export {};