stringzy 2.2.1 → 4.0.0

package/dist/transformations/numberToText/implementation_EN.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const helpers_1 = require("./helpers");
+/**
+ * Converts a number to its English textual representation.
+ *
+ * Handles negative numbers, numbers from 0 to 20, tens, hundreds, thousands, and larger magnitudes.
+ *
+ * @param num The number to convert.
+ * @returns The textual representation of the number in English.
+ */
+function numberToTextEn(num) {
+    if ((0, helpers_1.isNegative)(num)) {
+        return `minus ${numberToTextEn(Math.abs(num))}`;
+    }
+    // 0-20
+    if (num <= 20 && types_1.NUMBERS_EN[num]) {
+        return types_1.NUMBERS_EN[num];
+    }
+    // 21-99
+    if (num < 100) {
+        const tens = Math.floor(num / 10) * 10;
+        const ones = num % 10;
+        if (ones === 0) {
+            return types_1.NUMBERS_EN[tens];
+        }
+        return `${types_1.NUMBERS_EN[tens]}-${types_1.NUMBERS_EN[ones]}`;
+    }
+    // 100+
+    const magnitude = (0, helpers_1.getOrderOfMagnitude)(num);
+    const quotient = Math.floor(num / magnitude);
+    const remainder = num % magnitude;
+    // Special handling for hundreds
+    if (magnitude === 100) {
+        const result = `${numberToTextEn(quotient)} hundred`;
+        return remainder === 0 ? result : `${result} ${numberToTextEn(remainder)}`;
+    }
+    // 1000+
+    const magnitudeName = types_1.NUMBERS_EN[magnitude];
+    const quotientText = numberToTextEn(quotient);
+    const result = `${quotientText} ${magnitudeName}`;
+    return remainder === 0 ? result : `${result} ${numberToTextEn(remainder)}`;
+}
+exports.default = numberToTextEn;

package/dist/transformations/numberToText/implementation_PL.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Converts a number to its Polish textual representation.
+ *
+ * Handles negative numbers, numbers from 0 to billions, and applies correct Polish grammatical forms.
+ *
+ * @param num The number to convert.
+ * @returns The textual representation of the number in Polish.
+ */
+declare function numberToTextPl(num: number): string;
+export default numberToTextPl;

package/dist/transformations/numberToText/implementation_PL.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const helpers_1 = require("./helpers");
+/**
+ * Converts a number to its Polish textual representation.
+ *
+ * Handles negative numbers, numbers from 0 to billions, and applies correct Polish grammatical forms.
+ *
+ * @param num The number to convert.
+ * @returns The textual representation of the number in Polish.
+ */
+function numberToTextPl(num) {
+    if ((0, helpers_1.isNegative)(num)) {
+        return `minus ${numberToTextPl(Math.abs(num))}`;
+    }
+    // 0-20
+    if (num <= 20 && types_1.NUMBERS_PL[num]) {
+        return types_1.NUMBERS_PL[num];
+    }
+    // 21-99
+    if (num < 100) {
+        const tens = Math.floor(num / 10) * 10;
+        const ones = num % 10;
+        if (ones === 0) {
+            return types_1.NUMBERS_PL[tens];
+        }
+        return `${types_1.NUMBERS_PL[tens]} ${types_1.NUMBERS_PL[ones]}`;
+    }
+    // 100+
+    const magnitude = (0, helpers_1.getOrderOfMagnitude)(num);
+    const quotient = Math.floor(num / magnitude);
+    const remainder = num % magnitude;
+    // Special handling for hundreds
+    if (magnitude === 100) {
+        const hundredsForm = quotient * 100;
+        const result = types_1.NUMBERS_PL[hundredsForm];
+        return remainder === 0 ? result : `${result} ${numberToTextPl(remainder)}`;
+    }
+    // 1000+
+    let prefix = '';
+    if (quotient !== 1) {
+        prefix = numberToTextPl(quotient) + ' ';
+    }
+    const magnitudeForm = getPolishGrammaticalForm(magnitude, quotient);
+    const result = `${prefix}${magnitudeForm}`.trim();
+    return remainder === 0 ? result : `${result} ${numberToTextPl(remainder)}`;
+}
+/**
+ * Gets the correct grammatical form for Polish magnitude words
+ * based on the number (singular, few, many)
+ */
+function getPolishGrammaticalForm(magnitude, count) {
+    const forms = {
+        1000: ['tysiąc', 'tysiące', 'tysięcy'],
+        1000000: ['milion', 'miliony', 'milionów'],
+        1000000000: ['miliard', 'miliardy', 'miliardów'],
+        1000000000000: ['bilion', 'biliony', 'bilionów']
+    };
+    const formArray = forms[magnitude];
+    if (!formArray) {
+        throw new Error(`No grammatical forms defined for magnitude ${magnitude}`);
+    }
+    const lastTwoDigits = count % 100;
+    const lastDigit = count % 10;
+    if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
+        return formArray[2];
+    }
+    if (lastDigit === 1) {
+        return formArray[0];
+    }
+    else if (lastDigit >= 2 && lastDigit <= 4) {
+        return formArray[1];
+    }
+    else {
+        return formArray[2];
+    }
+}
+exports.default = numberToTextPl;

package/dist/transformations/numberToText/main.d.ts

@@ -0,0 +1,19 @@
+import { NumberToTextLanguage } from "./types";
+/**
+ * Converts a number to its text representation in the specified language.
+ *
+ * @param num - The number to convert (integer between -1,000,000,000,000 and 1,000,000,000,000)
+ * @param lang - The target language ('en' for English, 'pl' for Polish)
+ * @returns The text representation of the number
+ *
+ * @example
+ * numberToText(123) // "one hundred twenty-three"
+ * numberToText(123, 'pl') // "sto dwadzieścia trzy"
+ * numberToText(-45) // "minus forty-five"
+ * numberToText(1000000) // "one million"
+ * numberToText(1000000, 'pl') // "milion"
+ *
+ * @throws {TypeError} If num is not a valid integer or lang is not supported
+ * @throws {RangeError} If num is outside the supported range
+ */
+export declare function numberToText(num: number, lang?: NumberToTextLanguage): string;

package/dist/transformations/numberToText/main.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberToText = numberToText;
+const implementation_PL_1 = __importDefault(require("./implementation_PL"));
+const implementation_EN_1 = __importDefault(require("./implementation_EN"));
+/**
+ * Converts a number to its text representation in the specified language.
+ *
+ * @param num - The number to convert (integer between -1,000,000,000,000 and 1,000,000,000,000)
+ * @param lang - The target language ('en' for English, 'pl' for Polish)
+ * @returns The text representation of the number
+ *
+ * @example
+ * numberToText(123) // "one hundred twenty-three"
+ * numberToText(123, 'pl') // "sto dwadzieścia trzy"
+ * numberToText(-45) // "minus forty-five"
+ * numberToText(1000000) // "one million"
+ * numberToText(1000000, 'pl') // "milion"
+ *
+ * @throws {TypeError} If num is not a valid integer or lang is not supported
+ * @throws {RangeError} If num is outside the supported range
+ */
+function numberToText(num, lang = 'en') {
+    validateNumber(num);
+    validateLanguage(lang);
+    const langMap = {
+        en: implementation_EN_1.default,
+        pl: implementation_PL_1.default,
+    };
+    if (!langMap[lang]) {
+        throw new TypeError('Unsupported language');
+    }
+    return langMap[lang](num);
+}
+/////////////////////////////////////////
+//// Validation
+/////////////////////////////////////////
+/**
+ * Checks if the provided value is an integer within the allowed range.
+ *
+ * @param num - The value to check
+ * @throws {TypeError} If num is not an integer
+ * @throws {RangeError} If num is outside the range -1,000,000,000,000 to 1,000,000,000,000
+ */
+function validateNumber(num) {
+    if (typeof num !== 'number' || !Number.isInteger(num) || isNaN(num)) {
+        throw new TypeError('Num param should be number');
+    }
+    if (num < -1000000000000 || num > 1000000000000) {
+        throw new RangeError('Number must be between -1,000,000,000,000 and 1,000,000,000,000');
+    }
+}
+/**
+ * Checks if the provided language is supported.
+ *
+ * @param lang - The language code to check
+ * @throws {TypeError} If lang is not one of the supported languages
+ */
+function validateLanguage(lang) {
+    const validLanguages = ['en', 'pl'];
+    if (!validLanguages.includes(lang)) {
+        throw new TypeError(`Language must be one of: ${validLanguages.join(', ')}`);
+    }
+}

package/dist/transformations/numberToText/types.d.ts

@@ -0,0 +1,3 @@
+export type NumberToTextLanguage = 'en' | 'pl';
+export declare const NUMBERS_EN: Record<number, string>;
+export declare const NUMBERS_PL: Record<number, string>;

package/dist/transformations/numberToText/types.js

@@ -0,0 +1,82 @@
+"use strict";
+/////////////////////////////////////////
+//// Type Definitions
+/////////////////////////////////////////
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NUMBERS_PL = exports.NUMBERS_EN = void 0;
+/////////////////////////////////////////
+//// Language Dictionaries
+/////////////////////////////////////////
+exports.NUMBERS_EN = {
+    0: 'zero',
+    1: 'one',
+    2: 'two',
+    3: 'three',
+    4: 'four',
+    5: 'five',
+    6: 'six',
+    7: 'seven',
+    8: 'eight',
+    9: 'nine',
+    10: 'ten',
+    11: 'eleven',
+    12: 'twelve',
+    13: 'thirteen',
+    14: 'fourteen',
+    15: 'fifteen',
+    16: 'sixteen',
+    17: 'seventeen',
+    18: 'eighteen',
+    19: 'nineteen',
+    20: 'twenty',
+    30: 'thirty',
+    40: 'forty',
+    50: 'fifty',
+    60: 'sixty',
+    70: 'seventy',
+    80: 'eighty',
+    90: 'ninety',
+    1000: 'thousand',
+    1000000: 'million',
+    1000000000: 'billion',
+    1000000000000: 'trillion'
+};
+exports.NUMBERS_PL = {
+    0: 'zero',
+    1: 'jeden',
+    2: 'dwa',
+    3: 'trzy',
+    4: 'cztery',
+    5: 'pięć',
+    6: 'sześć',
+    7: 'siedem',
+    8: 'osiem',
+    9: 'dziewięć',
+    10: 'dziesięć',
+    11: 'jedenaście',
+    12: 'dwanaście',
+    13: 'trzynaście',
+    14: 'czternaście',
+    15: 'piętnaście',
+    16: 'szesnaście',
+    17: 'siedemnaście',
+    18: 'osiemnaście',
+    19: 'dziewiętnaście',
+    20: 'dwadzieścia',
+    30: 'trzydzieści',
+    40: 'czterdzieści',
+    50: 'pięćdziesiąt',
+    60: 'sześćdziesiąt',
+    70: 'siedemdziesiąt',
+    80: 'osiemdziesiąt',
+    90: 'dziewięćdziesiąt',
+    100: 'sto',
+    200: 'dwieście',
+    300: 'trzysta',
+    400: 'czterysta',
+    500: 'pięćset',
+    600: 'sześćset',
+    700: 'siedemset',
+    800: 'osiemset',
+    900: 'dziewięćset'
+};

package/dist/transformations/pascalCase.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Converts a given string to PascalCase format.
+ *
+ * The conversion process includes:
+ * - Trimming whitespace from both ends.
+ * - Converting all characters to lowercase.
+ * - Replacing non-word characters and underscores with spaces.
+ * - Collapsing multiple spaces into a single space.
+ * - Capitalizing the first letter of each word.
+ * - Removing all spaces to produce the PascalCase output.
+ *
+ * If the input is `null` or `undefined`, an empty string is returned.
+ *
+ * @param {string} text - The input string to convert.
+ * @returns {string} The PascalCase formatted string.
+ *
+ * @example
+ * pascalCase("hello world"); // "HelloWorld"
+ *
+ * @example
+ * pascalCase("convert_to-pascal.case"); // "ConvertToPascalCase"
+ *
+ * @example
+ * pascalCase("  multiple   spaces  here "); // "MultipleSpacesHere"
+ */
+export declare function pascalCase(text: string): string;

package/dist/transformations/pascalCase.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pascalCase = pascalCase;
+/**
+ * Converts a given string to PascalCase format.
+ *
+ * The conversion process includes:
+ * - Trimming whitespace from both ends.
+ * - Converting all characters to lowercase.
+ * - Replacing non-word characters and underscores with spaces.
+ * - Collapsing multiple spaces into a single space.
+ * - Capitalizing the first letter of each word.
+ * - Removing all spaces to produce the PascalCase output.
+ *
+ * If the input is `null` or `undefined`, an empty string is returned.
+ *
+ * @param {string} text - The input string to convert.
+ * @returns {string} The PascalCase formatted string.
+ *
+ * @example
+ * pascalCase("hello world"); // "HelloWorld"
+ *
+ * @example
+ * pascalCase("convert_to-pascal.case"); // "ConvertToPascalCase"
+ *
+ * @example
+ * pascalCase("  multiple   spaces  here "); // "MultipleSpacesHere"
+ */
+function pascalCase(text) {
+    if (text == null)
+        return '';
+    return text
+        .trim()
+        .toLowerCase()
+        .replace(/[^\w\s]/g, ' ')
+        .replace(/_/g, ' ')
+        .replace(/\s+/g, ' ')
+        .replace(/(^|\s)(.)/g, (_, prefix, character) => character.toUpperCase())
+        .replace(/\s/g, '');
+}

package/dist/transformations/removeDuplicates.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Removes duplicate words from a string, preserving the original word order.
+ *
+ * Splits the input string by spaces, filters out duplicate words,
+ * and joins the unique words back into a string separated by spaces.
+ *
+ * Throws an error if the input is not a string.
+ *
+ * @param {string} text - The input string from which duplicate words will be removed.
+ * @returns {string} A string containing only unique words in their original order.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * removeDuplicates("hello world hello"); // "hello world"
+ *
+ * @example
+ * removeDuplicates("this is is a test test"); // "this is a test"
+ *
+ * @example
+ * removeDuplicates(""); // ""
+ */
+export declare function removeDuplicates(text: string): string;

package/dist/transformations/removeDuplicates.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDuplicates = removeDuplicates;
+/**
+ * Removes duplicate words from a string, preserving the original word order.
+ *
+ * Splits the input string by spaces, filters out duplicate words,
+ * and joins the unique words back into a string separated by spaces.
+ *
+ * Throws an error if the input is not a string.
+ *
+ * @param {string} text - The input string from which duplicate words will be removed.
+ * @returns {string} A string containing only unique words in their original order.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * removeDuplicates("hello world hello"); // "hello world"
+ *
+ * @example
+ * removeDuplicates("this is is a test test"); // "this is a test"
+ *
+ * @example
+ * removeDuplicates(""); // ""
+ */
+function removeDuplicates(text) {
+    if (typeof text !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    const wordSet = new Set();
+    text.split(' ').forEach((word) => {
+        wordSet.add(word);
+    });
+    return Array.from(wordSet).join(' ');
+}

package/dist/transformations/removeSpecialChars.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Removes special characters from a string, replacing them with a specified string.
+ *
+ * Special characters are any characters except alphanumeric (`a-z`, `A-Z`, `0-9`) and whitespace.
+ * The default replacement is an empty string, effectively removing these characters.
+ *
+ * Throws an error if the input `text` or `replacement` is not a string.
+ *
+ * @param {string} text - The input string to process.
+ * @param {string} [replacement=''] - The string to replace special characters with.
+ * @returns {string} The processed string with special characters replaced.
+ * @throws {TypeError} If `text` or `replacement` is not a string.
+ *
+ * @example
+ * removeSpecialChars("Hello, World!"); // "Hello World"
+ *
+ * @example
+ * removeSpecialChars("Special #$% chars", '_'); // "Special ___ chars"
+ *
+ * @example
+ * removeSpecialChars("CleanText123"); // "CleanText123"
+ */
+export declare function removeSpecialChars(text: string, replacement?: string): string;

package/dist/transformations/removeSpecialChars.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSpecialChars = removeSpecialChars;
+/**
+ * Removes special characters from a string, replacing them with a specified string.
+ *
+ * Special characters are any characters except alphanumeric (`a-z`, `A-Z`, `0-9`) and whitespace.
+ * The default replacement is an empty string, effectively removing these characters.
+ *
+ * Throws an error if the input `text` or `replacement` is not a string.
+ *
+ * @param {string} text - The input string to process.
+ * @param {string} [replacement=''] - The string to replace special characters with.
+ * @returns {string} The processed string with special characters replaced.
+ * @throws {TypeError} If `text` or `replacement` is not a string.
+ *
+ * @example
+ * removeSpecialChars("Hello, World!"); // "Hello World"
+ *
+ * @example
+ * removeSpecialChars("Special #$% chars", '_'); // "Special ___ chars"
+ *
+ * @example
+ * removeSpecialChars("CleanText123"); // "CleanText123"
+ */
+function removeSpecialChars(text, replacement = '') {
+    if (typeof text !== 'string') {
+        throw new TypeError('Invalid argument. Expected a string.');
+    }
+    if (typeof replacement !== 'string') {
+        throw new TypeError('Replacement must be a string.');
+    }
+    return text.replace(/[^\w\s]/gi, replacement);
+}

package/dist/transformations/removeWords.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Removes specified word(s) from a given string.
+ *
+ * The function accepts either a single word as a string or an array of words to remove.
+ * It removes whole word matches case-insensitively, preserving spacing by collapsing
+ * multiple spaces into a single space and trimming the result.
+ *
+ * Throws `TypeError` if inputs are invalid or missing.
+ *
+ * @param {string} str - The input string from which words will be removed.
+ * @param {string | string[]} wordsToRemove - A word or array of words to remove from the input string.
+ * @returns {string} The string after removing the specified words.
+ * @throws {TypeError} If `str` is null, undefined, or not a string.
+ * @throws {TypeError} If `wordsToRemove` is null, undefined, or not a string or array of strings.
+ *
+ * @example
+ * removeWords("The quick brown fox jumps", "quick");
+ * // "The brown fox jumps"
+ *
+ * @example
+ * removeWords("The quick brown fox jumps over the lazy dog", ["quick", "lazy"]);
+ * // "The brown fox jumps over the dog"
+ *
+ * @example
+ * removeWords("Hello world", "world");
+ * // "Hello"
+ */
+export declare function removeWords(str: string, wordsToRemove: string | string[]): string;

package/dist/transformations/removeWords.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeWords = removeWords;
+/**
+ * Removes specified word(s) from a given string.
+ *
+ * The function accepts either a single word as a string or an array of words to remove.
+ * It removes whole word matches case-insensitively, preserving spacing by collapsing
+ * multiple spaces into a single space and trimming the result.
+ *
+ * Throws `TypeError` if inputs are invalid or missing.
+ *
+ * @param {string} str - The input string from which words will be removed.
+ * @param {string | string[]} wordsToRemove - A word or array of words to remove from the input string.
+ * @returns {string} The string after removing the specified words.
+ * @throws {TypeError} If `str` is null, undefined, or not a string.
+ * @throws {TypeError} If `wordsToRemove` is null, undefined, or not a string or array of strings.
+ *
+ * @example
+ * removeWords("The quick brown fox jumps", "quick");
+ * // "The brown fox jumps"
+ *
+ * @example
+ * removeWords("The quick brown fox jumps over the lazy dog", ["quick", "lazy"]);
+ * // "The brown fox jumps over the dog"
+ *
+ * @example
+ * removeWords("Hello world", "world");
+ * // "Hello"
+ */
+function removeWords(str, wordsToRemove) {
+    if (str === null || str === undefined) {
+        throw new TypeError('Input string cannot be null or undefined');
+    }
+    if (typeof str !== 'string') {
+        throw new TypeError('First parameter must be a string');
+    }
+    if (wordsToRemove === null || wordsToRemove === undefined) {
+        throw new TypeError('Words to remove cannot be null or undefined');
+    }
+    if (typeof wordsToRemove !== 'string' && !Array.isArray(wordsToRemove)) {
+        throw new TypeError('Second parameter must be a string or an array of strings');
+    }
+    if (str === '') {
+        return '';
+    }
+    const wordsArray = Array.isArray(wordsToRemove) ? wordsToRemove : [wordsToRemove];
+    const regex = new RegExp(`\\b(${wordsArray.join('|')})\\b`, 'gi');
+    return str.replace(regex, '').replace(/\s+/g, ' ').trim();
+}

package/dist/transformations/snakeCase.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Converts a given string to snake_case format.
+ *
+ * The transformation includes:
+ * - Trimming whitespace from both ends.
+ * - Replacing spaces and hyphens with underscores.
+ * - Inserting underscores between lowercase and uppercase letter boundaries (e.g., `fooBar` → `foo_bar`).
+ * - Replacing all non-word characters (except underscores) with underscores.
+ * - Converting the entire string to lowercase.
+ * - Collapsing multiple consecutive underscores into one.
+ * - Removing leading and trailing underscores.
+ *
+ * If the input is `null` or `undefined`, it returns an empty string.
+ *
+ * @param {string} text - The input string to convert.
+ * @returns {string} The snake_case formatted string.
+ *
+ * @example
+ * snakeCase("Hello World"); // "hello_world"
+ *
+ * @example
+ * snakeCase("camelCaseText"); // "camel_case_text"
+ *
+ * @example
+ * snakeCase("  convert-to--snake.case!  "); // "convert_to_snake_case"
+ */
+export declare function snakeCase(text: string): string;

package/dist/transformations/snakeCase.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snakeCase = snakeCase;
+/**
+ * Converts a given string to snake_case format.
+ *
+ * The transformation includes:
+ * - Trimming whitespace from both ends.
+ * - Replacing spaces and hyphens with underscores.
+ * - Inserting underscores between lowercase and uppercase letter boundaries (e.g., `fooBar` → `foo_bar`).
+ * - Replacing all non-word characters (except underscores) with underscores.
+ * - Converting the entire string to lowercase.
+ * - Collapsing multiple consecutive underscores into one.
+ * - Removing leading and trailing underscores.
+ *
+ * If the input is `null` or `undefined`, it returns an empty string.
+ *
+ * @param {string} text - The input string to convert.
+ * @returns {string} The snake_case formatted string.
+ *
+ * @example
+ * snakeCase("Hello World"); // "hello_world"
+ *
+ * @example
+ * snakeCase("camelCaseText"); // "camel_case_text"
+ *
+ * @example
+ * snakeCase("  convert-to--snake.case!  "); // "convert_to_snake_case"
+ */
+function snakeCase(text) {
+    if (text == null)
+        return '';
+    return text
+        .trim()
+        .replace(/[\s-]+/g, '_')
+        .replace(/([a-z])([A-Z])/g, '$1_$2')
+        .replace(/[^\w_]/g, '_')
+        .toLowerCase()
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}

package/dist/transformations/splitChunks.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates chunks of string based on a given chunk size
+ * @param text - Input string
+ * @param Number - Size of the chunk. Must be a positive integer. Defaults to 1.
+ * @returns An array of all the chunks created from the string based on the specified chunk size.
+ * @throws Error if input text is not a string or chunk size is not a positive integer.
+ */
+export declare function splitChunks(text: string, chunkSize?: Number): string[];