stringzy 4.1.0 → 4.2.0

package/dist/tests/formatting/temperature.test.js

@@ -0,0 +1,34 @@
+"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 temperature_1 = require("../../formatting/temperature");
+(0, node_test_1.describe)('formatTemperature', () => {
+    (0, node_test_1.it)('should convert Celsius to Fahrenheit', () => {
+        node_assert_1.default.strictEqual((0, temperature_1.formatTemperature)(0, { from: 'C', to: 'F' }), '32.00°F');
+    });
+    (0, node_test_1.it)('should convert Celsius to Kelvin', () => {
+        node_assert_1.default.strictEqual((0, temperature_1.formatTemperature)(100, { from: 'C', to: 'K' }), '373.15K');
+    });
+    (0, node_test_1.it)('should convert Fahrenheit to Celsius', () => {
+        node_assert_1.default.strictEqual((0, temperature_1.formatTemperature)(32, { from: 'F', to: 'C' }), '0.00°C');
+    });
+    (0, node_test_1.it)('should convert Fahrenheit to Kelvin', () => {
+        node_assert_1.default.strictEqual((0, temperature_1.formatTemperature)(212, { from: 'F', to: 'K' }), '373.15K');
+    });
+    (0, node_test_1.it)('should convert Kelvin to Celsius', () => {
+        node_assert_1.default.strictEqual((0, temperature_1.formatTemperature)(300, { from: 'K', to: 'C' }), '26.85°C');
+    });
+    (0, node_test_1.it)('should handle precision settings', () => {
+        node_assert_1.default.strictEqual((0, temperature_1.formatTemperature)(100, { from: 'C', to: 'K', precision: 0 }), '373K');
+    });
+    (0, node_test_1.it)('should throw error for invalid conversions', () => {
+        node_assert_1.default.throws(() => (0, temperature_1.formatTemperature)(100, { from: 'C', to: 'X' }), /Invalid conversion from C to X./);
+    });
+    (0, node_test_1.it)('should throw error for non-numeric value', () => {
+        node_assert_1.default.throws(() => (0, temperature_1.formatTemperature)(NaN, { from: 'C', to: 'K' }), /Invalid temperature value./);
+    });
+});

package/dist/tests/formatting/trim.test.d.ts

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

package/dist/tests/formatting/trim.test.js

@@ -0,0 +1,42 @@
+"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"));
+// NOTE: Adjust this import path to match your project structure
+const trim_1 = require("../../formatting/trim");
+(0, node_test_1.describe)('trim', () => {
+    (0, node_test_1.it)('removes simple leading and trailing spaces', () => {
+        node_assert_1.default.strictEqual((0, trim_1.trim)(' hello world '), 'hello world');
+        node_assert_1.default.strictEqual((0, trim_1.trim)('   leading'), 'leading');
+        node_assert_1.default.strictEqual((0, trim_1.trim)('trailing   '), 'trailing');
+    });
+    (0, node_test_1.it)('collapses multiple spaces between words into one', () => {
+        node_assert_1.default.strictEqual((0, trim_1.trim)('multiple   spaces'), 'multiple spaces');
+        node_assert_1.default.strictEqual((0, trim_1.trim)('one  two   three    four'), 'one two three four');
+    });
+    (0, node_test_1.it)('handles tabs and line breaks as whitespace', () => {
+        node_assert_1.default.strictEqual((0, trim_1.trim)('line \n breaks\tand  tabs'), 'line breaks and tabs');
+        node_assert_1.default.strictEqual((0, trim_1.trim)('tabs\tbetween\twords'), 'tabs between words');
+        node_assert_1.default.strictEqual((0, trim_1.trim)('new\nlines\n\nand\r\nwindows'), 'new lines and windows');
+    });
+    (0, node_test_1.it)('handles a complex mix of all whitespace types', () => {
+        const input = ' \n  \t hello \n\n world \t  !   ';
+        const expected = 'hello world !';
+        node_assert_1.default.strictEqual((0, trim_1.trim)(input), expected);
+    });
+    (0, node_test_1.it)('handles edge cases: empty and whitespace-only strings', () => {
+        node_assert_1.default.strictEqual((0, trim_1.trim)(''), '');
+        node_assert_1.default.strictEqual((0, trim_1.trim)('   '), '');
+        node_assert_1.default.strictEqual((0, trim_1.trim)(' \n \t \r\n '), '');
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, trim_1.trim)(123), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, trim_1.trim)(null), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, trim_1.trim)(undefined), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, trim_1.trim)({}), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, trim_1.trim)([]), /Input must be a string/);
+    });
+});

package/dist/tests/transformations/stringPermutations.test.js

@@ -37,4 +37,74 @@ const stringPermutations_1 = require("../../transformations/stringPermutations")
         node_assert_1.default.throws(() => (0, stringPermutations_1.stringPermutations)(null), /Input must be a string/);
         node_assert_1.default.throws(() => (0, stringPermutations_1.stringPermutations)(undefined), /Input must be a string/);
     });
+    (0, node_test_1.it)('respects limit parameter', () => {
+        const result = (0, stringPermutations_1.stringPermutations)('abcdef', 3);
+        node_assert_1.default.strictEqual(result.length, 3);
+        // All results should be valid permutations
+        for (const perm of result) {
+            node_assert_1.default.strictEqual(perm.length, 6);
+            node_assert_1.default.strictEqual([...perm].sort().join(''), 'abcdef');
+        }
+    });
+    (0, node_test_1.it)('throws error for negative limit', () => {
+        node_assert_1.default.throws(() => (0, stringPermutations_1.stringPermutations)('abc', -1), /Limit must be non-negative/);
+    });
+    (0, node_test_1.it)('handles limit of 0', () => {
+        const result = (0, stringPermutations_1.stringPermutations)('abc', 0);
+        node_assert_1.default.strictEqual(result.length, 0);
+    });
+    (0, node_test_1.it)('handles limit larger than total permutations', () => {
+        const result = (0, stringPermutations_1.stringPermutations)('abc', 100);
+        node_assert_1.default.strictEqual(result.length, 6); // 3! = 6
+    });
+});
+(0, node_test_1.describe)('stringPermutationsGenerator', () => {
+    (0, node_test_1.it)('yields correct permutations for small strings', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('ab')).sort();
+        node_assert_1.default.deepStrictEqual(result, ['ab', 'ba']);
+    });
+    (0, node_test_1.it)('yields all permutations for 3 unique characters', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('abc')).sort();
+        const expected = ['abc', 'acb', 'bac', 'bca', 'cab', 'cba'];
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.it)('handles repeated characters correctly', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('aab')).sort();
+        const expected = ['aab', 'aba', 'baa'];
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.it)('handles single character input', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('a'));
+        node_assert_1.default.deepStrictEqual(result, ['a']);
+    });
+    (0, node_test_1.it)('handles empty string input', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)(''));
+        node_assert_1.default.deepStrictEqual(result, ['']);
+    });
+    (0, node_test_1.it)('is case-sensitive', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('Ab')).sort();
+        const expected = ['Ab', 'bA'];
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.it)('handles special characters', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('!@')).sort();
+        const expected = ['!@', '@!'];
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        // Generator functions throw when first consumed, not when created
+        const gen1 = (0, stringPermutations_1.stringPermutationsGenerator)(123);
+        node_assert_1.default.throws(() => gen1.next(), /Input must be a string/);
+        const gen2 = (0, stringPermutations_1.stringPermutationsGenerator)(null);
+        node_assert_1.default.throws(() => gen2.next(), /Input must be a string/);
+        const gen3 = (0, stringPermutations_1.stringPermutationsGenerator)(undefined);
+        node_assert_1.default.throws(() => gen3.next(), /Input must be a string/);
+    });
+    (0, node_test_1.it)('can be used with for...of loop', () => {
+        const results = [];
+        for (const perm of (0, stringPermutations_1.stringPermutationsGenerator)('abc')) {
+            results.push(perm);
+        }
+        node_assert_1.default.strictEqual(results.length, 6);
+    });
 });

package/dist/tests/validations/isIPv6.test.d.ts

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

package/dist/tests/validations/isIPv6.test.js

@@ -0,0 +1,65 @@
+"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 isIPv6_1 = require("../../validations/isIPv6");
+(0, node_test_1.describe)('isIPv6', () => {
+    (0, node_test_1.it)('returns true for valid full IPv6 addresses', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:0db8:85a3:0000:0000:8a2e:0370:7334'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('0:0:0:0:0:0:0:1'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('fe80:0000:0000:0000:0202:b3ff:fe1e:8329'), true);
+    });
+    (0, node_test_1.it)('returns true for valid shorthand IPv6 addresses', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3::8a2e:370:7334'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('::1'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('fe80::1'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('::'), true);
+    });
+    (0, node_test_1.it)('returns false for IPv6 addresses with too many groups', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:0db8:85a3:0000:0000:8a2e:0370:7334:1234'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('1:2:3:4:5:6:7:8:9'), false);
+    });
+    (0, node_test_1.it)('returns false for IPv6 addresses with too few groups without shorthand', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3:8a2e:370:7334'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('1:2:3:4:5:6:7'), false);
+    });
+    (0, node_test_1.it)('returns false for invalid use of shorthand (::)', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:::1'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)(':::1'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001::85a3::7334'), false);
+    });
+    (0, node_test_1.it)('returns false for groups longer than 4 hex digits', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('12345::abcd'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3:00000:0000:8a2e:0370:7334'), false);
+    });
+    (0, node_test_1.it)('returns false for invalid characters', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3:z000:0000:8a2e:0370:7334'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3:0000:0000:8a2e:0370:g334'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('abcd:efgh:ijkl:mnop:qrst:uvwx:yz12:3456'), false);
+    });
+    (0, node_test_1.it)('returns false for special characters and malformed strings', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3:0000:0000:8a2e:0370:7334:'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)(':2001:db8:85a3:0000:0000:8a2e:0370:7334'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8::85a3::7334'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8::85a3:7334:'), false);
+    });
+    (0, node_test_1.it)('returns false for empty strings and edge cases', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)(''), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)(':'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)(':::'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('::::'), false);
+    });
+    (0, node_test_1.it)('returns true for uppercase valid IPv6 addresses (case-insensitive)', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:DB8:85A3::8A2E:370:7334'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('FE80::1'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF'), true);
+    });
+    (0, node_test_1.it)('returns false for IPv4-mapped IPv6 (unsupported by this validator)', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('::ffff:192.168.1.1'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8::192.168.1.1'), false);
+    });
+});

package/dist/transformations/index.d.ts

@@ -15,7 +15,7 @@ export { escapeHtml } from './escapeHTML';
 export { maskSegment } from './maskSegment';
 export { numberToText } from './numberToText/main';
 export { reverseWordsInString } from './reverseWordsInString ';
-export { stringPermutations } from './stringPermutations';
+export { stringPermutations, stringPermutationsGenerator } from './stringPermutations';
 export { stringCombinations } from './stringCombinations';
 import { camelCase } from './camelCase';
 import { capitalizeWords } from './capitalizeWords';
@@ -35,7 +35,7 @@ import { maskSegment } from './maskSegment';
 import { deburr } from './deburr';
 import { numberToText } from './numberToText/main';
 import { reverseWordsInString } from './reverseWordsInString ';
-import { stringPermutations } from './stringPermutations';
+import { stringPermutations, stringPermutationsGenerator } from './stringPermutations';
 import { stringCombinations } from './stringCombinations';
 export declare const transformations: {
     camelCase: typeof camelCase;
@@ -57,5 +57,6 @@ export declare const transformations: {
     numberToText: typeof numberToText;
     reverseWordsInString: typeof reverseWordsInString;
     stringPermutations: typeof stringPermutations;
+    stringPermutationsGenerator: typeof stringPermutationsGenerator;
     stringCombinations: typeof stringCombinations;
 };

package/dist/transformations/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformations = exports.stringCombinations = exports.stringPermutations = exports.reverseWordsInString = exports.numberToText = exports.maskSegment = exports.escapeHtml = exports.truncateText = exports.toSlug = exports.titleCase = exports.snakeCase = exports.removeWords = exports.removeSpecialChars = exports.removeDuplicates = exports.pascalCase = exports.kebabCase = exports.initials = exports.constantCase = exports.capitalizeWords = exports.camelCase = void 0;
+exports.transformations = exports.stringCombinations = exports.stringPermutationsGenerator = exports.stringPermutations = exports.reverseWordsInString = exports.numberToText = exports.maskSegment = exports.escapeHtml = exports.truncateText = exports.toSlug = exports.titleCase = exports.snakeCase = exports.removeWords = exports.removeSpecialChars = exports.removeDuplicates = exports.pascalCase = exports.kebabCase = exports.initials = exports.constantCase = exports.capitalizeWords = exports.camelCase = void 0;
 var camelCase_1 = require("./camelCase");
 Object.defineProperty(exports, "camelCase", { enumerable: true, get: function () { return camelCase_1.camelCase; } });
 var capitalizeWords_1 = require("./capitalizeWords");
@@ -37,6 +37,7 @@ var reverseWordsInString_1 = require("./reverseWordsInString ");
 Object.defineProperty(exports, "reverseWordsInString", { enumerable: true, get: function () { return reverseWordsInString_1.reverseWordsInString; } });
 var stringPermutations_1 = require("./stringPermutations");
 Object.defineProperty(exports, "stringPermutations", { enumerable: true, get: function () { return stringPermutations_1.stringPermutations; } });
+Object.defineProperty(exports, "stringPermutationsGenerator", { enumerable: true, get: function () { return stringPermutations_1.stringPermutationsGenerator; } });
 var stringCombinations_1 = require("./stringCombinations");
 Object.defineProperty(exports, "stringCombinations", { enumerable: true, get: function () { return stringCombinations_1.stringCombinations; } });
 const camelCase_2 = require("./camelCase");
@@ -79,5 +80,6 @@ exports.transformations = {
     numberToText: main_2.numberToText,
     reverseWordsInString: reverseWordsInString_2.reverseWordsInString,
     stringPermutations: stringPermutations_2.stringPermutations,
+    stringPermutationsGenerator: stringPermutations_2.stringPermutationsGenerator,
     stringCombinations: stringCombinations_2.stringCombinations
 };

package/dist/transformations/stringPermutations.d.ts

@@ -4,9 +4,14 @@
  * Handles repeated characters by ensuring only unique permutations
  * are included in the result. The order of permutations is not guaranteed.
  *
+ * Performance optimized version using iterative approach and efficient
+ * character frequency tracking to avoid duplicate permutations.
+ *
  * @param {string} str - The input string to generate permutations for.
+ * @param {number} [limit] - Optional limit on number of permutations to generate.
  * @returns {string[]} An array of unique permutations of the input string.
  * @throws {TypeError} If the input is not a string.
+ * @throws {RangeError} If limit is negative.
  *
  * @example
  * stringPermutations("ab");
@@ -21,6 +26,10 @@
  * // ["aab", "aba", "baa"]
  *
  * @example
+ * stringPermutations("abcdef", 10);
+ * // Returns first 10 permutations
+ *
+ * @example
  * stringPermutations("");
  * // [""]
  *
@@ -28,4 +37,17 @@
  * stringPermutations("a");
  * // ["a"]
  */
-export declare function stringPermutations(str: string): string[];
+export declare function stringPermutations(str: string, limit?: number): string[];
+/**
+ * Generator function for permutations - yields permutations one at a time.
+ * This is the most memory-efficient approach for very large strings.
+ *
+ * @param {string} str - The input string to generate permutations for.
+ * @yields {string} Each unique permutation.
+ *
+ * @example
+ * for (const perm of stringPermutationsGenerator("abc")) {
+ *   console.log(perm);
+ * }
+ */
+export declare function stringPermutationsGenerator(str: string): Generator<string, void, unknown>;

package/dist/transformations/stringPermutations.js

@@ -1,15 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stringPermutations = stringPermutations;
+exports.stringPermutationsGenerator = stringPermutationsGenerator;
 /**
  * Generates all unique permutations of a given string.
  *
  * Handles repeated characters by ensuring only unique permutations
  * are included in the result. The order of permutations is not guaranteed.
  *
+ * Performance optimized version using iterative approach and efficient
+ * character frequency tracking to avoid duplicate permutations.
+ *
  * @param {string} str - The input string to generate permutations for.
+ * @param {number} [limit] - Optional limit on number of permutations to generate.
  * @returns {string[]} An array of unique permutations of the input string.
  * @throws {TypeError} If the input is not a string.
+ * @throws {RangeError} If limit is negative.
  *
  * @example
  * stringPermutations("ab");
@@ -24,6 +30,10 @@ exports.stringPermutations = stringPermutations;
  * // ["aab", "aba", "baa"]
  *
  * @example
+ * stringPermutations("abcdef", 10);
+ * // Returns first 10 permutations
+ *
+ * @example
  * stringPermutations("");
  * // [""]
  *
@@ -31,19 +41,40 @@ exports.stringPermutations = stringPermutations;
  * stringPermutations("a");
  * // ["a"]
  */
-function stringPermutations(str) {
+function stringPermutations(str, limit) {
     if (typeof str !== 'string') {
         throw new TypeError('Input must be a string');
     }
+    if (limit !== undefined && limit < 0) {
+        throw new RangeError('Limit must be non-negative');
+    }
     if (str.length === 0)
         return [''];
+    // For small strings, use the original approach for simplicity
+    if (str.length <= 6) {
+        return generatePermutationsSmall(str, limit);
+    }
+    // For larger strings, use optimized approach
+    return generatePermutationsOptimized(str, limit);
+}
+/**
+ * Generates permutations for small strings (≤6 characters) using recursive approach.
+ * This is more memory efficient for small inputs.
+ */
+function generatePermutationsSmall(str, limit) {
     const results = new Set();
+    let count = 0;
     const permute = (prefix, remaining) => {
+        if (limit !== undefined && count >= limit)
+            return;
         if (remaining.length === 0) {
             results.add(prefix);
+            count++;
         }
         else {
             for (let i = 0; i < remaining.length; i++) {
+                if (limit !== undefined && count >= limit)
+                    break;
                 permute(prefix + remaining[i], remaining.slice(0, i) + remaining.slice(i + 1));
             }
         }
@@ -51,3 +82,98 @@ function stringPermutations(str) {
     permute('', str);
     return Array.from(results);
 }
+/**
+ * Generates permutations for larger strings using optimized iterative approach.
+ * Uses character frequency tracking to avoid duplicate permutations efficiently.
+ */
+function generatePermutationsOptimized(str, limit) {
+    // Count character frequencies
+    const charCount = new Map();
+    for (const char of str) {
+        charCount.set(char, (charCount.get(char) || 0) + 1);
+    }
+    const results = [];
+    const chars = Array.from(charCount.keys());
+    const counts = chars.map(char => charCount.get(char));
+    // Use iterative approach with stack to avoid recursion
+    const stack = [{
+            permutation: '',
+            remainingCounts: [...counts],
+            depth: 0
+        }];
+    while (stack.length > 0) {
+        if (limit !== undefined && results.length >= limit)
+            break;
+        const current = stack.pop();
+        if (current.depth === str.length) {
+            results.push(current.permutation);
+            continue;
+        }
+        // Generate next level permutations
+        for (let i = 0; i < chars.length; i++) {
+            if (current.remainingCounts[i] > 0) {
+                const newCounts = [...current.remainingCounts];
+                newCounts[i]--;
+                stack.push({
+                    permutation: current.permutation + chars[i],
+                    remainingCounts: newCounts,
+                    depth: current.depth + 1
+                });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Generator function for permutations - yields permutations one at a time.
+ * This is the most memory-efficient approach for very large strings.
+ *
+ * @param {string} str - The input string to generate permutations for.
+ * @yields {string} Each unique permutation.
+ *
+ * @example
+ * for (const perm of stringPermutationsGenerator("abc")) {
+ *   console.log(perm);
+ * }
+ */
+function* stringPermutationsGenerator(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (str.length === 0) {
+        yield '';
+        return;
+    }
+    // Count character frequencies
+    const charCount = new Map();
+    for (const char of str) {
+        charCount.set(char, (charCount.get(char) || 0) + 1);
+    }
+    const chars = Array.from(charCount.keys());
+    const counts = chars.map(char => charCount.get(char));
+    // Use iterative approach with stack
+    const stack = [{
+            permutation: '',
+            remainingCounts: [...counts],
+            depth: 0
+        }];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current.depth === str.length) {
+            yield current.permutation;
+            continue;
+        }
+        // Generate next level permutations
+        for (let i = 0; i < chars.length; i++) {
+            if (current.remainingCounts[i] > 0) {
+                const newCounts = [...current.remainingCounts];
+                newCounts[i]--;
+                stack.push({
+                    permutation: current.permutation + chars[i],
+                    remainingCounts: newCounts,
+                    depth: current.depth + 1
+                });
+            }
+        }
+    }
+}

package/dist/validations/index.d.ts

@@ -5,6 +5,7 @@ export { isEmpty } from './isEmpty';
 export { isSlug } from './isSlug';
 export { isURL } from './isURL';
 export { isIPv4 } from './isIPv4';
+export { isIPv6 } from './isIPv6';
 export { isHexColor } from './isHexColor';
 export { isPalindrome } from './isPalindrome';
 export { isLowerCase } from './isLowerCase';
@@ -21,6 +22,7 @@ import { isEmpty } from './isEmpty';
 import { isSlug } from './isSlug';
 import { isURL } from './isURL';
 import { isIPv4 } from './isIPv4';
+import { isIPv6 } from './isIPv6';
 import { isHexColor } from './isHexColor';
 import { isPalindrome } from './isPalindrome';
 import { isLowerCase } from './isLowerCase';
@@ -38,6 +40,7 @@ export declare const validations: {
     isSlug: typeof isSlug;
     isURL: typeof isURL;
     isIPv4: typeof isIPv4;
+    isIPv6: typeof isIPv6;
     isHexColor: typeof isHexColor;
     isPalindrome: typeof isPalindrome;
     isLowerCase: typeof isLowerCase;

package/dist/validations/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validations = exports.isMacAddress = exports.isPanagram = exports.isAnagram = exports.isAlphaNumeric = exports.isAlphabetic = exports.isUpperCase = exports.isLowerCase = exports.isPalindrome = exports.isHexColor = exports.isIPv4 = exports.isURL = exports.isSlug = exports.isEmpty = exports.isEmail = exports.isDate = exports.isCoordinates = void 0;
+exports.validations = exports.isMacAddress = exports.isPanagram = exports.isAnagram = exports.isAlphaNumeric = exports.isAlphabetic = exports.isUpperCase = exports.isLowerCase = exports.isPalindrome = exports.isHexColor = exports.isIPv6 = exports.isIPv4 = exports.isURL = exports.isSlug = exports.isEmpty = exports.isEmail = exports.isDate = exports.isCoordinates = void 0;
 var isCoordinates_1 = require("./isCoordinates");
 Object.defineProperty(exports, "isCoordinates", { enumerable: true, get: function () { return isCoordinates_1.isCoordinates; } });
 var isDate_1 = require("./isDate");
@@ -15,6 +15,8 @@ var isURL_1 = require("./isURL");
 Object.defineProperty(exports, "isURL", { enumerable: true, get: function () { return isURL_1.isURL; } });
 var isIPv4_1 = require("./isIPv4");
 Object.defineProperty(exports, "isIPv4", { enumerable: true, get: function () { return isIPv4_1.isIPv4; } });
+var isIPv6_1 = require("./isIPv6");
+Object.defineProperty(exports, "isIPv6", { enumerable: true, get: function () { return isIPv6_1.isIPv6; } });
 var isHexColor_1 = require("./isHexColor");
 Object.defineProperty(exports, "isHexColor", { enumerable: true, get: function () { return isHexColor_1.isHexColor; } });
 var isPalindrome_1 = require("./isPalindrome");
@@ -40,6 +42,7 @@ const isEmpty_2 = require("./isEmpty");
 const isSlug_2 = require("./isSlug");
 const isURL_2 = require("./isURL");
 const isIPv4_2 = require("./isIPv4");
+const isIPv6_2 = require("./isIPv6");
 const isHexColor_2 = require("./isHexColor");
 const isPalindrome_2 = require("./isPalindrome");
 const isLowerCase_2 = require("./isLowerCase");
@@ -57,6 +60,7 @@ exports.validations = {
     isSlug: isSlug_2.isSlug,
     isURL: isURL_2.isURL,
     isIPv4: isIPv4_2.isIPv4,
+    isIPv6: isIPv6_2.isIPv6,
     isHexColor: isHexColor_2.isHexColor,
     isPalindrome: isPalindrome_2.isPalindrome,
     isLowerCase: isLowerCase_2.isLowerCase,

package/dist/validations/isIPv6.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Checks if a given string is a valid IPv6 address.
+ *
+ * Valid IPv6 addresses consist of eight groups of four hexadecimal digits (0-9, a-f, A-F)
+ * separated by colons (:). Each group can have 1 to 4 hex digits.
+ * Leading zeros are allowed. IPv6 addresses can also use the "::" shorthand once
+ * to represent one or more groups of zeros.
+ *
+ * @param {string} str - The string to validate as an IPv6 address.
+ * @returns {boolean} `true` if the string is a valid IPv6 address, otherwise `false`.
+ *
+ * @example
+ * isIPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334"); // true
+ *
+ * @example
+ * isIPv6("2001:db8:85a3::8a2e:370:7334"); // true (uses shorthand)
+ *
+ * @example
+ * isIPv6("2001:db8:::1"); // false (invalid use of shorthand)
+ *
+ * @example
+ * isIPv6("12345::abcd"); // false (group too long)
+ */
+export declare function isIPv6(str: string): boolean;

package/dist/validations/isIPv6.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIPv6 = isIPv6;
+/**
+ * Checks if a given string is a valid IPv6 address.
+ *
+ * Valid IPv6 addresses consist of eight groups of four hexadecimal digits (0-9, a-f, A-F)
+ * separated by colons (:). Each group can have 1 to 4 hex digits.
+ * Leading zeros are allowed. IPv6 addresses can also use the "::" shorthand once
+ * to represent one or more groups of zeros.
+ *
+ * @param {string} str - The string to validate as an IPv6 address.
+ * @returns {boolean} `true` if the string is a valid IPv6 address, otherwise `false`.
+ *
+ * @example
+ * isIPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334"); // true
+ *
+ * @example
+ * isIPv6("2001:db8:85a3::8a2e:370:7334"); // true (uses shorthand)
+ *
+ * @example
+ * isIPv6("2001:db8:::1"); // false (invalid use of shorthand)
+ *
+ * @example
+ * isIPv6("12345::abcd"); // false (group too long)
+ */
+function isIPv6(str) {
+    const lower = str.toLowerCase();
+    if (!/^[0-9a-f:]+$/.test(lower))
+        return false;
+    const parts = lower.split("::");
+    if (parts.length > 2)
+        return false;
+    const left = parts[0] ? parts[0].split(":") : [];
+    const right = parts[1] ? parts[1].split(":") : [];
+    // Each part (excluding shorthand) must be 1–4 hex digits
+    const validGroup = (g) => /^[0-9a-f]{1,4}$/.test(g);
+    if (!left.every(validGroup) || !right.every(validGroup))
+        return false;
+    const totalGroups = left.length + right.length;
+    if (parts.length === 1)
+        return totalGroups === 8;
+    else
+        return totalGroups < 8;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stringzy",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {