stringzy 4.1.0 → 4.2.0

package/dist/formatting/hexadecimal.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatToHexadecimal = formatToHexadecimal;
+/**
+ * Converts a decimal number to its hexadecimal (base-16) representation.
+ *
+ * @param {number} num - The decimal number to convert.
+ * @param {object} [options] - Optional formatting options.
+ * @param {boolean} [options.prefix=false] - Whether to add "0x" before the result.
+ * @param {boolean} [options.lowercase=false] - Whether to return hexadecimal in lowercase.
+ * @returns {string} The hexadecimal representation of the number.
+ * @throws {TypeError} If the input is not a valid number.
+ */
+function formatToHexadecimal(num, options) {
+    if (typeof num !== 'number' || isNaN(num)) {
+        throw new TypeError('Input must be a valid number');
+    }
+    const { prefix = false, lowercase = false } = options || {};
+    // Convert number to hexadecimal (absolute value first to handle negatives)
+    let hex = Math.abs(num).toString(16).toUpperCase();
+    if (lowercase) {
+        hex = hex.toLowerCase();
+    }
+    // Add negative sign if original number was negative
+    if (num < 0) {
+        hex = '-' + hex;
+    }
+    // Add prefix (0x or -0x) if enabled
+    if (prefix) {
+        if (hex.startsWith('-')) {
+            hex = '-0x' + hex.slice(1);
+        }
+        else {
+            hex = '0x' + hex;
+        }
+    }
+    return hex;
+}

package/dist/formatting/index.d.ts

@@ -1,11 +1,53 @@
 export { capitalize } from './capitalize';
 export { formatNumber } from './number';
 export { formatPhone } from './phone';
+export { formatDuration } from './duration';
+export { trim } from './trim';
+export { formatRomanNumeral } from './romanNumerals';
+export { formatPercentage } from './percentage';
+export { formatFileSize } from './fileSize';
+export { formatOrdinal } from './ordinal';
+export { formatList } from './listToString';
+export { formatCreditCard } from './creditCard';
+export { formatToOctal } from './octal';
+export { formatTemperature } from './temperature';
+export { formatScientific } from './scientific';
+export { formatToBinary } from './binary';
+export { formatToHexadecimal } from './hexadecimal';
+export { formatToDecimal } from './decimal';
 import { capitalize } from './capitalize';
 import { formatNumber } from './number';
 import { formatPhone } from './phone';
+import { formatDuration } from './duration';
+import { trim } from './trim';
+import { formatRomanNumeral } from './romanNumerals';
+import { formatPercentage } from './percentage';
+import { formatFileSize } from './fileSize';
+import { formatOrdinal } from './ordinal';
+import { formatList } from './listToString';
+import { formatCreditCard } from './creditCard';
+import { formatToOctal } from './octal';
+import { formatTemperature } from './temperature';
+import { formatScientific } from './scientific';
+import { formatToBinary } from './binary';
+import { formatToHexadecimal } from './hexadecimal';
+import { formatToDecimal } from './decimal';
 export declare const formatting: {
     capitalize: typeof capitalize;
     formatNumber: typeof formatNumber;
     formatPhone: typeof formatPhone;
+    formatDuration: typeof formatDuration;
+    trim: typeof trim;
+    formatRomanNumeral: typeof formatRomanNumeral;
+    formatPercentage: typeof formatPercentage;
+    formatFileSize: typeof formatFileSize;
+    formatOrdinal: typeof formatOrdinal;
+    formatList: typeof formatList;
+    formatTemperature: typeof formatTemperature;
+    formatScientific: typeof formatScientific;
+    formatCreditCard: typeof formatCreditCard;
+    formatToBinary: typeof formatToBinary;
+    formatToHexadecimal: typeof formatToHexadecimal;
+    formatToOctal: typeof formatToOctal;
+    formatToDecimal: typeof formatToDecimal;
 };

package/dist/formatting/index.js

@@ -1,17 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatting = exports.formatPhone = exports.formatNumber = exports.capitalize = void 0;
+exports.formatting = exports.formatToDecimal = exports.formatToHexadecimal = exports.formatToBinary = exports.formatScientific = exports.formatTemperature = exports.formatToOctal = exports.formatCreditCard = exports.formatList = exports.formatOrdinal = exports.formatFileSize = exports.formatPercentage = exports.formatRomanNumeral = exports.trim = exports.formatDuration = 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; } });
+var duration_1 = require("./duration");
+Object.defineProperty(exports, "formatDuration", { enumerable: true, get: function () { return duration_1.formatDuration; } });
+var trim_1 = require("./trim");
+Object.defineProperty(exports, "trim", { enumerable: true, get: function () { return trim_1.trim; } });
+var romanNumerals_1 = require("./romanNumerals");
+Object.defineProperty(exports, "formatRomanNumeral", { enumerable: true, get: function () { return romanNumerals_1.formatRomanNumeral; } });
+var percentage_1 = require("./percentage");
+Object.defineProperty(exports, "formatPercentage", { enumerable: true, get: function () { return percentage_1.formatPercentage; } });
+var fileSize_1 = require("./fileSize");
+Object.defineProperty(exports, "formatFileSize", { enumerable: true, get: function () { return fileSize_1.formatFileSize; } });
+var ordinal_1 = require("./ordinal");
+Object.defineProperty(exports, "formatOrdinal", { enumerable: true, get: function () { return ordinal_1.formatOrdinal; } });
+var listToString_1 = require("./listToString");
+Object.defineProperty(exports, "formatList", { enumerable: true, get: function () { return listToString_1.formatList; } });
+var creditCard_1 = require("./creditCard");
+Object.defineProperty(exports, "formatCreditCard", { enumerable: true, get: function () { return creditCard_1.formatCreditCard; } });
+var octal_1 = require("./octal");
+Object.defineProperty(exports, "formatToOctal", { enumerable: true, get: function () { return octal_1.formatToOctal; } });
+var temperature_1 = require("./temperature");
+Object.defineProperty(exports, "formatTemperature", { enumerable: true, get: function () { return temperature_1.formatTemperature; } });
+var scientific_1 = require("./scientific");
+Object.defineProperty(exports, "formatScientific", { enumerable: true, get: function () { return scientific_1.formatScientific; } });
+var binary_1 = require("./binary");
+Object.defineProperty(exports, "formatToBinary", { enumerable: true, get: function () { return binary_1.formatToBinary; } });
+var hexadecimal_1 = require("./hexadecimal");
+Object.defineProperty(exports, "formatToHexadecimal", { enumerable: true, get: function () { return hexadecimal_1.formatToHexadecimal; } });
+var decimal_1 = require("./decimal");
+Object.defineProperty(exports, "formatToDecimal", { enumerable: true, get: function () { return decimal_1.formatToDecimal; } });
 const capitalize_2 = require("./capitalize");
 const number_2 = require("./number");
 const phone_2 = require("./phone");
+const duration_2 = require("./duration");
+const trim_2 = require("./trim");
+const romanNumerals_2 = require("./romanNumerals");
+const percentage_2 = require("./percentage");
+const fileSize_2 = require("./fileSize");
+const ordinal_2 = require("./ordinal");
+const listToString_2 = require("./listToString");
+const creditCard_2 = require("./creditCard");
+const octal_2 = require("./octal");
+const temperature_2 = require("./temperature");
+const scientific_2 = require("./scientific");
+const binary_2 = require("./binary");
+const hexadecimal_2 = require("./hexadecimal");
+const decimal_2 = require("./decimal");
 exports.formatting = {
     capitalize: capitalize_2.capitalize,
     formatNumber: number_2.formatNumber,
     formatPhone: phone_2.formatPhone,
+    formatDuration: duration_2.formatDuration,
+    trim: trim_2.trim,
+    formatRomanNumeral: romanNumerals_2.formatRomanNumeral,
+    formatPercentage: percentage_2.formatPercentage,
+    formatFileSize: fileSize_2.formatFileSize,
+    formatOrdinal: ordinal_2.formatOrdinal,
+    formatList: listToString_2.formatList,
+    formatTemperature: temperature_2.formatTemperature,
+    formatScientific: scientific_2.formatScientific,
+    formatCreditCard: creditCard_2.formatCreditCard,
+    formatToBinary: binary_2.formatToBinary,
+    formatToHexadecimal: hexadecimal_2.formatToHexadecimal,
+    formatToOctal: octal_2.formatToOctal,
+    formatToDecimal: decimal_2.formatToDecimal
 };

package/dist/formatting/listToString.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Formats an array of strings into a human-readable list with proper commas and "and".
+ *
+ * Supports the Oxford comma for lists of three or more items.
+ * Returns an empty string for empty arrays.
+ *
+ * Examples:
+ * ["apples", "bananas", "cherries"] → "apples, bananas, and cherries"
+ * ["apples", "bananas"] → "apples and bananas"
+ * ["apple"] → "apple"
+ * [] → ""
+ *
+ * @param {string[]} arr - The array of strings to format into a readable list.
+ * @returns {string} The formatted human-readable list.
+ * @throws {TypeError} If the input is not an array of strings.
+ */
+export declare function formatList(arr: string[]): string;

package/dist/formatting/listToString.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatList = formatList;
+/**
+ * Formats an array of strings into a human-readable list with proper commas and "and".
+ *
+ * Supports the Oxford comma for lists of three or more items.
+ * Returns an empty string for empty arrays.
+ *
+ * Examples:
+ * ["apples", "bananas", "cherries"] → "apples, bananas, and cherries"
+ * ["apples", "bananas"] → "apples and bananas"
+ * ["apple"] → "apple"
+ * [] → ""
+ *
+ * @param {string[]} arr - The array of strings to format into a readable list.
+ * @returns {string} The formatted human-readable list.
+ * @throws {TypeError} If the input is not an array of strings.
+ */
+function formatList(arr) {
+    if (!Array.isArray(arr)) {
+        throw new TypeError('Input must be an array');
+    }
+    if (!arr.every(item => typeof item === 'string')) {
+        throw new TypeError('All elements in the array must be strings');
+    }
+    const len = arr.length;
+    if (len === 0)
+        return '';
+    if (len === 1)
+        return arr[0];
+    if (len === 2)
+        return `${arr[0]} and ${arr[1]}`;
+    return `${arr.slice(0, -1).join(', ')}, and ${arr[len - 1]}`;
+}

package/dist/formatting/octal.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts a decimal number to its octal (base-8) string representation.
+ *
+ * Supports negative numbers and an optional "0o" prefix.
+ *
+ * Examples:
+ * 8   → "10"
+ * 10  → "12"
+ * 255 → "377"
+ * 0   → "0"
+ *
+ * @param {number} num - The decimal number to convert.
+ * @param {{ prefix?: boolean }} [options] - Optional formatting options.
+ * @returns {string} The octal string representation, optionally prefixed with "0o".
+ * @throws {TypeError} If the input is not a number or is NaN.
+ */
+export declare function formatToOctal(num: number, options?: {
+    prefix?: boolean;
+}): string;

package/dist/formatting/octal.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatToOctal = formatToOctal;
+/**
+ * Converts a decimal number to its octal (base-8) string representation.
+ *
+ * Supports negative numbers and an optional "0o" prefix.
+ *
+ * Examples:
+ * 8   → "10"
+ * 10  → "12"
+ * 255 → "377"
+ * 0   → "0"
+ *
+ * @param {number} num - The decimal number to convert.
+ * @param {{ prefix?: boolean }} [options] - Optional formatting options.
+ * @returns {string} The octal string representation, optionally prefixed with "0o".
+ * @throws {TypeError} If the input is not a number or is NaN.
+ */
+function formatToOctal(num, options) {
+    if (typeof num !== 'number' || Number.isNaN(num)) {
+        throw new TypeError('Input must be a number');
+    }
+    const includePrefix = (options === null || options === void 0 ? void 0 : options.prefix) === true;
+    const isNegative = num < 0;
+    const absoluteValue = Math.abs(num);
+    const octalCore = absoluteValue.toString(8);
+    const prefix = includePrefix ? '0o' : '';
+    const signedCore = `${prefix}${octalCore}`;
+    return isNegative ? `-${signedCore}` : signedCore;
+}

package/dist/formatting/ordinal.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a number into its ordinal string representation (e.g., 1 → "1st", 2 → "2nd").
+ *
+ * Handles special cases for 11, 12, and 13, which always use "th" regardless of their last digit.
+ * Supports both small and large numbers.
+ *
+ * Examples:
+ * 1 → "1st"
+ * 2 → "2nd"
+ * 3 → "3rd"
+ * 4 → "4th"
+ * 11 → "11th"
+ * 21 → "21st"
+ * 113 → "113th"
+ *
+ * @param {number} num - The number to convert to an ordinal string.
+ * @returns {string} The formatted ordinal string (e.g., "21st").
+ * @throws {TypeError} If the input is not a number.
+ */
+export declare function formatOrdinal(num: number): string;

package/dist/formatting/ordinal.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOrdinal = formatOrdinal;
+/**
+ * Converts a number into its ordinal string representation (e.g., 1 → "1st", 2 → "2nd").
+ *
+ * Handles special cases for 11, 12, and 13, which always use "th" regardless of their last digit.
+ * Supports both small and large numbers.
+ *
+ * Examples:
+ * 1 → "1st"
+ * 2 → "2nd"
+ * 3 → "3rd"
+ * 4 → "4th"
+ * 11 → "11th"
+ * 21 → "21st"
+ * 113 → "113th"
+ *
+ * @param {number} num - The number to convert to an ordinal string.
+ * @returns {string} The formatted ordinal string (e.g., "21st").
+ * @throws {TypeError} If the input is not a number.
+ */
+function formatOrdinal(num) {
+    if (typeof num !== 'number' || Number.isNaN(num)) {
+        throw new TypeError('Input must be a number');
+    }
+    const absNum = Math.abs(num);
+    const lastTwoDigits = absNum % 100;
+    if (lastTwoDigits >= 11 && lastTwoDigits <= 13) {
+        return `${num}th`;
+    }
+    const lastDigit = absNum % 10;
+    switch (lastDigit) {
+        case 1:
+            return `${num}st`;
+        case 2:
+            return `${num}nd`;
+        case 3:
+            return `${num}rd`;
+        default:
+            return `${num}th`;
+    }
+}

package/dist/formatting/percentage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts a number into a percentage string with configurable decimal precision.
+ *
+ * Supports positive, negative, and whole numbers.
+ *
+ * Examples:
+ * 0.567 → "56.70%"
+ * 0.567 → "56.7%" (precision = 1)
+ * 0.5   → "50%"
+ * 1     → "100%"
+ * -0.25 → "-25%"
+ * 50    → "5000%"
+ *
+ * @param {number} num - The number to convert into a percentage.
+ * @param {number} [precision=2] - The number of decimal places to include.
+ * @returns {string} The formatted percentage string.
+ * @throws {TypeError} If the input is not a number or precision is not a number.
+ */
+export declare function formatPercentage(num: number, precision?: number): string;

package/dist/formatting/percentage.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPercentage = formatPercentage;
+/**
+ * Converts a number into a percentage string with configurable decimal precision.
+ *
+ * Supports positive, negative, and whole numbers.
+ *
+ * Examples:
+ * 0.567 → "56.70%"
+ * 0.567 → "56.7%" (precision = 1)
+ * 0.5   → "50%"
+ * 1     → "100%"
+ * -0.25 → "-25%"
+ * 50    → "5000%"
+ *
+ * @param {number} num - The number to convert into a percentage.
+ * @param {number} [precision=2] - The number of decimal places to include.
+ * @returns {string} The formatted percentage string.
+ * @throws {TypeError} If the input is not a number or precision is not a number.
+ */
+function formatPercentage(num, precision = 2) {
+    if (typeof num !== 'number' || Number.isNaN(num)) {
+        throw new TypeError('Input must be a number');
+    }
+    if (typeof precision !== 'number' || Number.isNaN(precision) || precision < 0) {
+        throw new TypeError('Precision must be a non-negative number');
+    }
+    const percentage = num * 100;
+    return `${percentage.toFixed(precision)}%`;
+}

package/dist/formatting/romanNumerals.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a positive integer into its Roman numeral representation.
+ *
+ * Supports numbers from 1 to 3999 using standard Roman numeral notation.
+ *
+ * Examples:
+ * 1     → "I"
+ * 4     → "IV"
+ * 9     → "IX"
+ * 58    → "LVIII"
+ * 1994  → "MCMXCIV"
+ * 2025  → "MMXXV"
+ * 3999  → "MMMCMXCIX"
+ *
+ * @param {number} num - The positive integer to convert (1–3999).
+ * @returns {string} The Roman numeral representation of the given number.
+ * @throws {RangeError} If the number is less than or equal to 0, or greater than 3999.
+ * @throws {TypeError} If the input is not a number.
+ */
+export declare function formatRomanNumeral(num: number): string;

package/dist/formatting/romanNumerals.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatRomanNumeral = formatRomanNumeral;
+/**
+ * Converts a positive integer into its Roman numeral representation.
+ *
+ * Supports numbers from 1 to 3999 using standard Roman numeral notation.
+ *
+ * Examples:
+ * 1     → "I"
+ * 4     → "IV"
+ * 9     → "IX"
+ * 58    → "LVIII"
+ * 1994  → "MCMXCIV"
+ * 2025  → "MMXXV"
+ * 3999  → "MMMCMXCIX"
+ *
+ * @param {number} num - The positive integer to convert (1–3999).
+ * @returns {string} The Roman numeral representation of the given number.
+ * @throws {RangeError} If the number is less than or equal to 0, or greater than 3999.
+ * @throws {TypeError} If the input is not a number.
+ */
+function formatRomanNumeral(num) {
+    if (typeof num !== 'number' || Number.isNaN(num)) {
+        throw new TypeError('Input must be a number');
+    }
+    if (num <= 0) {
+        throw new RangeError('Roman numerals are only defined for positive integers');
+    }
+    if (num > 3999) {
+        throw new RangeError('Roman numerals are supported only up to 3999');
+    }
+    const values = [
+        1000, 900, 500, 400,
+        100, 90, 50, 40,
+        10, 9, 5, 4, 1
+    ];
+    const symbols = [
+        'M', 'CM', 'D', 'CD',
+        'C', 'XC', 'L', 'XL',
+        'X', 'IX', 'V', 'IV', 'I'
+    ];
+    let result = '';
+    let i = 0;
+    while (num > 0) {
+        while (num >= values[i]) {
+            result += symbols[i];
+            num -= values[i];
+        }
+        i++;
+    }
+    return result;
+}

package/dist/formatting/scientific.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Converts a number to scientific (exponential) notation.
+ *
+ * @param {number} num - The number to convert.
+ * @param {object} [options] - Optional formatting settings.
+ * @param {number} [options.precision=2] - Number of digits after the decimal point.
+ * @param {boolean} [options.uppercase=false] - Whether to use uppercase "E" in the notation.
+ * @returns {string} Scientific notation of the number.
+ * @throws {TypeError} If input is not a valid number.
+ */
+export declare function formatScientific(num: number, options?: {
+    precision?: number;
+    uppercase?: boolean;
+}): string;

package/dist/formatting/scientific.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatScientific = formatScientific;
+/**
+ * Converts a number to scientific (exponential) notation.
+ *
+ * @param {number} num - The number to convert.
+ * @param {object} [options] - Optional formatting settings.
+ * @param {number} [options.precision=2] - Number of digits after the decimal point.
+ * @param {boolean} [options.uppercase=false] - Whether to use uppercase "E" in the notation.
+ * @returns {string} Scientific notation of the number.
+ * @throws {TypeError} If input is not a valid number.
+ */
+function formatScientific(num, options) {
+    if (typeof num !== 'number' || isNaN(num)) {
+        throw new TypeError('Input must be a valid number');
+    }
+    const { precision = 2, uppercase = false } = options || {};
+    let scientific = num.toExponential(precision);
+    if (uppercase) {
+        scientific = scientific.replace('e', 'E');
+    }
+    return scientific;
+}

package/dist/formatting/temperature.d.ts

@@ -0,0 +1,6 @@
+declare function formatTemperature(value: number, options: {
+    from: string;
+    to: string;
+    precision?: number;
+}): string;
+export { formatTemperature };

package/dist/formatting/temperature.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTemperature = formatTemperature;
+function formatTemperature(value, options) {
+    const { from, to, precision = 2 } = options;
+    const conversions = {
+        'C_F': (v) => (v * 9) / 5 + 32,
+        'C_K': (v) => v + 273.15,
+        'F_C': (v) => ((v - 32) * 5) / 9,
+        'F_K': (v) => ((v - 32) * 5) / 9 + 273.15,
+        'K_C': (v) => v - 273.15,
+        'K_F': (v) => ((v - 273.15) * 9) / 5 + 32
+    };
+    const conversionKey = `${from}_${to}`;
+    const convert = conversions[conversionKey];
+    if (!convert) {
+        throw new Error(`Invalid conversion from ${from} to ${to}.`);
+    }
+    if (typeof value !== 'number' || isNaN(value)) {
+        throw new Error('Invalid temperature value.');
+    }
+    const convertedValue = convert(value);
+    if (to === 'K') {
+        return `${convertedValue.toFixed(precision)}K`;
+    }
+    return `${convertedValue.toFixed(precision)}°${to}`;
+}

package/dist/formatting/trim.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Removes unnecessary whitespace from a string.
+ * This includes leading/trailing spaces, multiple consecutive spaces, tabs, and line breaks.
+ * The result is a clean, single-spaced string.
+ *
+ * @param {string} str - The input string to format.
+ * @returns {string} The trimmed and normalized string.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function trim(str: string): string;

package/dist/formatting/trim.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trim = trim;
+/**
+ * Removes unnecessary whitespace from a string.
+ * This includes leading/trailing spaces, multiple consecutive spaces, tabs, and line breaks.
+ * The result is a clean, single-spaced string.
+ *
+ * @param {string} str - The input string to format.
+ * @returns {string} The trimmed and normalized string.
+ * @throws {TypeError} If the input is not a string.
+ */
+function trim(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    // 1. Trim leading/trailing whitespace (including newlines/tabs)
+    // 2. Replace multiple internal whitespace chars (including \n, \t) with a single space
+    return str.trim().replace(/\s+/g, ' ');
+}

package/dist/index.d.ts

@@ -15,11 +15,26 @@ declare const _default: {
         checkMultiplePatterns: typeof import("./analyzing").checkMultiplePatterns;
         checkSubsequence: typeof import("./analyzing").checkSubsequence;
         checkStringRotations: typeof import("./analyzing").checkStringRotations;
+        lexicographicalRank: typeof import("./analyzing").lexicographicalRank;
     };
     formatting: {
         capitalize: typeof import("./formatting").capitalize;
         formatNumber: typeof import("./formatting").formatNumber;
         formatPhone: typeof import("./formatting").formatPhone;
+        formatDuration: typeof import("./formatting").formatDuration;
+        trim: typeof import("./formatting").trim;
+        formatRomanNumeral: typeof import("./formatting").formatRomanNumeral;
+        formatPercentage: typeof import("./formatting").formatPercentage;
+        formatFileSize: typeof import("./formatting").formatFileSize;
+        formatOrdinal: typeof import("./formatting").formatOrdinal;
+        formatList: typeof import("./formatting").formatList;
+        formatTemperature: typeof import("./formatting").formatTemperature;
+        formatScientific: typeof import("./formatting").formatScientific;
+        formatCreditCard: typeof import("./formatting").formatCreditCard;
+        formatToBinary: typeof import("./formatting").formatToBinary;
+        formatToHexadecimal: typeof import("./formatting").formatToHexadecimal;
+        formatToOctal: typeof import("./formatting").formatToOctal;
+        formatToDecimal: typeof import("./formatting").formatToDecimal;
     };
     transformations: {
         camelCase: typeof import("./transformations").camelCase;
@@ -41,6 +56,7 @@ declare const _default: {
         numberToText: typeof import("./transformations").numberToText;
         reverseWordsInString: typeof import("./transformations").reverseWordsInString;
         stringPermutations: typeof import("./transformations").stringPermutations;
+        stringPermutationsGenerator: typeof import("./transformations").stringPermutationsGenerator;
         stringCombinations: typeof import("./transformations").stringCombinations;
     };
     validations: {
@@ -51,6 +67,7 @@ declare const _default: {
         isSlug: typeof import("./validations").isSlug;
         isURL: typeof import("./validations").isURL;
         isIPv4: typeof import("./validations").isIPv4;
+        isIPv6: typeof import("./validations").isIPv6;
         isHexColor: typeof import("./validations").isHexColor;
         isPalindrome: typeof import("./validations").isPalindrome;
         isLowerCase: typeof import("./validations").isLowerCase;

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

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