@catbee/utils 1.1.0 → 2.0.0-next.1

package/stream/index.cjs

@@ -0,0 +1,151 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+'use strict';
+
+var stream = require('stream');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function bufferToStream(data) {
+  const readable = new stream.Readable();
+  readable.push(data);
+  readable.push(null);
+  return readable;
+}
+__name(bufferToStream, "bufferToStream");
+async function streamToBuffer(stream) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", reject);
+  });
+}
+__name(streamToBuffer, "streamToBuffer");
+async function streamToString(stream, encoding = "utf8") {
+  const buffer = await streamToBuffer(stream);
+  return buffer.toString(encoding);
+}
+__name(streamToString, "streamToString");
+function createThrottleStream(bytesPerSecond) {
+  let bytesSent = 0;
+  let startTime = Date.now();
+  return new stream.Transform({
+    transform(chunk, _encoding, callback) {
+      const elapsedSeconds = (Date.now() - startTime) / 1e3;
+      const targetBytes = bytesPerSecond * elapsedSeconds;
+      const chunkSize = chunk.length;
+      if (bytesSent + chunkSize <= targetBytes) {
+        bytesSent += chunkSize;
+        callback(null, chunk);
+        return;
+      }
+      const delay = ((bytesSent + chunkSize) / bytesPerSecond - elapsedSeconds) * 1e3;
+      setTimeout(() => {
+        bytesSent += chunkSize;
+        callback(null, chunk);
+      }, delay);
+    }
+  });
+}
+__name(createThrottleStream, "createThrottleStream");
+function createBatchStream(size, options = {}) {
+  const objectMode = options.objectMode !== false;
+  let batch = [];
+  let buffers = [];
+  let bufferSize = 0;
+  return new stream.Transform({
+    objectMode,
+    transform(chunk, _encoding, callback) {
+      if (objectMode) {
+        batch.push(chunk);
+        if (batch.length >= size) {
+          this.push(batch);
+          batch = [];
+        }
+      } else {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        buffers.push(buffer);
+        bufferSize += buffer.length;
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        buffers = combined.length > 0 ? [
+          combined
+        ] : [];
+        bufferSize = combined.length;
+      }
+      callback();
+    },
+    flush(callback) {
+      if (objectMode && batch.length > 0) {
+        this.push(batch);
+      } else if (!objectMode && buffers.length > 0 && bufferSize > 0) {
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        if (combined.length > 0) {
+          this.push(combined);
+        }
+      }
+      callback();
+    }
+  });
+}
+__name(createBatchStream, "createBatchStream");
+function createLineStream(options = {}) {
+  const { encoding = "utf8", includeNewlines = false } = options;
+  let buffer = "";
+  return new stream.Transform({
+    objectMode: true,
+    transform(chunk, _encoding, callback) {
+      const str = buffer + (Buffer.isBuffer(chunk) ? chunk.toString(encoding) : chunk);
+      const lines = str.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        this.push(includeNewlines ? line + "\n" : line);
+      }
+      callback();
+    },
+    flush(callback) {
+      if (buffer) {
+        this.push(buffer);
+      }
+      callback();
+    }
+  });
+}
+__name(createLineStream, "createLineStream");
+
+exports.bufferToStream = bufferToStream;
+exports.createBatchStream = createBatchStream;
+exports.createLineStream = createLineStream;
+exports.createThrottleStream = createThrottleStream;
+exports.streamToBuffer = streamToBuffer;
+exports.streamToString = streamToString;

package/stream/index.d.ts

@@ -0,0 +1,114 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Readable, Transform } from 'node:stream';
+import { BufferEncoding } from '@catbee/utils/crypto';
+
+/**
+ * Convert a buffer or string to a readable stream.
+ *
+ * @param data - Buffer or string to convert
+ * @returns Readable stream containing the data
+ *
+ * @example
+ * ```typescript
+ * const stream = bufferToStream(Buffer.from('Hello world'));
+ * // or
+ * const stream = bufferToStream('Hello world');
+ * ```
+ */
+declare function bufferToStream(data: Buffer | string): Readable;
+/**
+ * Convert a readable stream to a buffer.
+ *
+ * @param stream - Readable stream to convert
+ * @returns Promise resolving to a buffer containing all stream data
+ *
+ * @example
+ * ```typescript
+ * const buffer = await streamToBuffer(fs.createReadStream('file.txt'));
+ * console.log(buffer.toString()); // Contents of file.txt
+ * ```
+ */
+declare function streamToBuffer(stream: Readable): Promise<Buffer>;
+/**
+ * Convert a readable stream to a string.
+ *
+ * @param stream - Readable stream to convert
+ * @param encoding - Character encoding (default: 'utf8')
+ * @returns Promise resolving to a string containing all stream data
+ *
+ * @example
+ * ```typescript
+ * const content = await streamToString(fs.createReadStream('file.txt'));
+ * console.log(content); // Contents of file.txt as string
+ * ```
+ */
+declare function streamToString(stream: Readable, encoding?: BufferEncoding): Promise<string>;
+/**
+ * Create a transform stream that limits the rate of data flow.
+ *
+ * @param bytesPerSecond - Maximum bytes per second
+ * @returns Transform stream that throttles data flow
+ */
+declare function createThrottleStream(bytesPerSecond: number): Transform;
+/**
+ * Create a transform stream that batches data into chunks of specified size.
+ *
+ * @param size - Size of each batch (items for object mode, bytes for binary mode)
+ * @param options - Stream options
+ * @returns Transform stream that batches data
+ *
+ * @example
+ * ```typescript
+ * // Batch lines from a file into arrays of 100 lines each
+ * createReadStream('large-file.txt')
+ *   .pipe(createLineStream())
+ *   .pipe(createBatchStream(100))
+ *   .on('data', batch => console.log(`Processing batch of ${batch.length} lines`));
+ * ```
+ */
+declare function createBatchStream(size: number, options?: {
+    objectMode?: boolean;
+}): Transform;
+/**
+ * Create a transform stream that splits text data by newlines.
+ *
+ * @param options - Options for the line stream
+ * @returns Transform stream that emits lines
+ *
+ * @example
+ * ```typescript
+ * // Process a file line by line
+ * createReadStream('file.txt')
+ *   .pipe(createLineStream())
+ *   .on('data', line => console.log(`Line: ${line}`));
+ * ```
+ */
+declare function createLineStream(options?: {
+    encoding?: BufferEncoding;
+    includeNewlines?: boolean;
+}): Transform;
+
+export { bufferToStream, createBatchStream, createLineStream, createThrottleStream, streamToBuffer, streamToString };

package/stream/index.mjs

@@ -0,0 +1,144 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Readable, Transform } from 'stream';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function bufferToStream(data) {
+  const readable = new Readable();
+  readable.push(data);
+  readable.push(null);
+  return readable;
+}
+__name(bufferToStream, "bufferToStream");
+async function streamToBuffer(stream) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", reject);
+  });
+}
+__name(streamToBuffer, "streamToBuffer");
+async function streamToString(stream, encoding = "utf8") {
+  const buffer = await streamToBuffer(stream);
+  return buffer.toString(encoding);
+}
+__name(streamToString, "streamToString");
+function createThrottleStream(bytesPerSecond) {
+  let bytesSent = 0;
+  let startTime = Date.now();
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      const elapsedSeconds = (Date.now() - startTime) / 1e3;
+      const targetBytes = bytesPerSecond * elapsedSeconds;
+      const chunkSize = chunk.length;
+      if (bytesSent + chunkSize <= targetBytes) {
+        bytesSent += chunkSize;
+        callback(null, chunk);
+        return;
+      }
+      const delay = ((bytesSent + chunkSize) / bytesPerSecond - elapsedSeconds) * 1e3;
+      setTimeout(() => {
+        bytesSent += chunkSize;
+        callback(null, chunk);
+      }, delay);
+    }
+  });
+}
+__name(createThrottleStream, "createThrottleStream");
+function createBatchStream(size, options = {}) {
+  const objectMode = options.objectMode !== false;
+  let batch = [];
+  let buffers = [];
+  let bufferSize = 0;
+  return new Transform({
+    objectMode,
+    transform(chunk, _encoding, callback) {
+      if (objectMode) {
+        batch.push(chunk);
+        if (batch.length >= size) {
+          this.push(batch);
+          batch = [];
+        }
+      } else {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        buffers.push(buffer);
+        bufferSize += buffer.length;
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        buffers = combined.length > 0 ? [
+          combined
+        ] : [];
+        bufferSize = combined.length;
+      }
+      callback();
+    },
+    flush(callback) {
+      if (objectMode && batch.length > 0) {
+        this.push(batch);
+      } else if (!objectMode && buffers.length > 0 && bufferSize > 0) {
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        if (combined.length > 0) {
+          this.push(combined);
+        }
+      }
+      callback();
+    }
+  });
+}
+__name(createBatchStream, "createBatchStream");
+function createLineStream(options = {}) {
+  const { encoding = "utf8", includeNewlines = false } = options;
+  let buffer = "";
+  return new Transform({
+    objectMode: true,
+    transform(chunk, _encoding, callback) {
+      const str = buffer + (Buffer.isBuffer(chunk) ? chunk.toString(encoding) : chunk);
+      const lines = str.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        this.push(includeNewlines ? line + "\n" : line);
+      }
+      callback();
+    },
+    flush(callback) {
+      if (buffer) {
+        this.push(buffer);
+      }
+      callback();
+    }
+  });
+}
+__name(createLineStream, "createLineStream");
+
+export { bufferToStream, createBatchStream, createLineStream, createThrottleStream, streamToBuffer, streamToString };

package/string/index.cjs

@@ -0,0 +1,109 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/string/string.utils.ts
+function capitalize(str) {
+  if (typeof str !== "string") throw new TypeError("Expected a string");
+  return str.length === 0 ? "" : str.charAt(0).toUpperCase() + str.slice(1);
+}
+__name(capitalize, "capitalize");
+function toKebabCase(str) {
+  if (typeof str !== "string") throw new TypeError("Expected a string");
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/\s+/g, "-").replace(/_+/g, "-").toLowerCase();
+}
+__name(toKebabCase, "toKebabCase");
+function toCamelCase(str) {
+  if (typeof str !== "string") throw new TypeError("Expected a string");
+  return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase());
+}
+__name(toCamelCase, "toCamelCase");
+function slugify(str) {
+  return str.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+__name(slugify, "slugify");
+function truncate(str, len) {
+  return str.length > len ? str.slice(0, len) + "..." : str;
+}
+__name(truncate, "truncate");
+function toPascalCase(str) {
+  return capitalize(toCamelCase(str));
+}
+__name(toPascalCase, "toPascalCase");
+function toSnakeCase(str) {
+  return str.trim().replace(/([a-z])([A-Z])/g, "$1_$2").replace(/\s+/g, "_").replace(/-+/g, "_").toLowerCase();
+}
+__name(toSnakeCase, "toSnakeCase");
+function mask(str, visibleStart = 0, visibleEnd = 0, maskChar = "*") {
+  if (!str || str.length === 0) return "";
+  if (visibleStart >= str.length) return str;
+  const start = str.slice(0, visibleStart);
+  const end = visibleEnd > 0 ? str.slice(-visibleEnd) : "";
+  const masked = maskChar.repeat(Math.max(0, str.length - visibleStart - visibleEnd));
+  return start + masked + end;
+}
+__name(mask, "mask");
+function stripHtml(str) {
+  return str.replace(/<[^>]*>/g, "");
+}
+__name(stripHtml, "stripHtml");
+function equalsIgnoreCase(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+__name(equalsIgnoreCase, "equalsIgnoreCase");
+function reverse(str) {
+  return str.split("").reverse().join("");
+}
+__name(reverse, "reverse");
+function countOccurrences(str, substring, caseSensitive = true) {
+  if (!caseSensitive) {
+    str = str.toLowerCase();
+    substring = substring.toLowerCase();
+  }
+  return str.split(substring).length - 1;
+}
+__name(countOccurrences, "countOccurrences");
+function toTitleCase(str) {
+  if (typeof str !== "string") throw new TypeError("Expected a string");
+  return str.split(/(\s+)/).map((part) => part.trim().length === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+__name(toTitleCase, "toTitleCase");
+
+exports.capitalize = capitalize;
+exports.countOccurrences = countOccurrences;
+exports.equalsIgnoreCase = equalsIgnoreCase;
+exports.mask = mask;
+exports.reverse = reverse;
+exports.slugify = slugify;
+exports.stripHtml = stripHtml;
+exports.toCamelCase = toCamelCase;
+exports.toKebabCase = toKebabCase;
+exports.toPascalCase = toPascalCase;
+exports.toSnakeCase = toSnakeCase;
+exports.toTitleCase = toTitleCase;
+exports.truncate = truncate;

package/string/index.d.ts

@@ -0,0 +1,126 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * Capitalizes the first character of a string.
+ *
+ * @param {string} str - The input string.
+ * @returns {string} The string with the first character in uppercase.
+ */
+declare function capitalize(str: string): string;
+/**
+ * Converts a string to kebab-case (e.g., "FooBar test" -> "foo-bar-test").
+ *
+ * @param {string} str - The input string.
+ * @returns {string} The kebab-cased string.
+ */
+declare function toKebabCase(str: string): string;
+/**
+ * Converts a kebab-case or snake_case string to camelCase.
+ *
+ * @param {string} str - The input string.
+ * @returns {string} The camelCased string.
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Converts a string to a URL-friendly slug (lowercase, dashes, alphanumeric).
+ *
+ * @param {string} str - The input string.
+ * @returns {string} The slugified string.
+ */
+declare function slugify(str: string): string;
+/**
+ * Truncates a string to a specific length, appending '...' if truncated.
+ *
+ * @param {string} str - The input string.
+ * @param {number} len - The maximum length.
+ * @returns {string} The truncated string.
+ */
+declare function truncate(str: string, len: number): string;
+/**
+ * Converts a string to PascalCase (e.g., "foo-bar" -> "FooBar").
+ *
+ * @param {string} str - The input string.
+ * @returns {string} The PascalCased string.
+ */
+declare function toPascalCase(str: string): string;
+/**
+ * Converts a string to snake_case (e.g., "FooBar test" -> "foo_bar_test").
+ *
+ * @param {string} str - The input string.
+ * @returns {string} The snake_cased string.
+ */
+declare function toSnakeCase(str: string): string;
+/**
+ * Masks a string by replacing characters with a mask character.
+ * Useful for hiding sensitive information like credit cards or passwords.
+ *
+ * @param {string} str - The string to mask.
+ * @param {number} [visibleStart=0] - Number of characters to show at start.
+ * @param {number} [visibleEnd=0] - Number of characters to show at end.
+ * @param {string} [maskChar="*"] - Character to use for masking.
+ * @returns {string} The masked string.
+ */
+declare function mask(str: string, visibleStart?: number, visibleEnd?: number, maskChar?: string): string;
+/**
+ * Removes all HTML tags from a string.
+ *
+ * @param {string} str - The HTML string to process.
+ * @returns {string} The string with HTML tags removed.
+ */
+declare function stripHtml(str: string): string;
+/**
+ * Performs case-insensitive string comparison.
+ *
+ * @param {string} a - First string.
+ * @param {string} b - Second string.
+ * @returns {boolean} True if the strings are equal ignoring case.
+ */
+declare function equalsIgnoreCase(a: string, b: string): boolean;
+/**
+ * Reverses a string.
+ *
+ * @param {string} str - The string to reverse.
+ * @returns {string} The reversed string.
+ */
+declare function reverse(str: string): string;
+/**
+ * Counts occurrences of a substring within a string.
+ *
+ * @param {string} str - The source string.
+ * @param {string} substring - The substring to count.
+ * @param {boolean} [caseSensitive=true] - Whether to perform case-sensitive counting.
+ * @returns {number} Number of occurrences.
+ */
+declare function countOccurrences(str: string, substring: string, caseSensitive?: boolean): number;
+/**
+ * Convert a string to Title Case (each word capitalized).
+ * Preserves existing spacing and punctuation between words.
+ *
+ * @param str - Input string
+ * @returns Title-cased string
+ */
+declare function toTitleCase(str: string): string;
+
+export { capitalize, countOccurrences, equalsIgnoreCase, mask, reverse, slugify, stripHtml, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, toTitleCase, truncate };