@naman_deep_singh/utils 2.1.0

package/dist/cjs/index.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPerformanceConfig = exports.setPerformanceConfig = exports.LRUCache = exports.hasOwnProperty = exports.getPathSegments = exports.safeClone = exports.ensurePositiveInteger = exports.isValidArrayIndex = exports.mergeConfigs = exports.validatePerformanceSettings = exports.validateConfig = exports.validatePositiveInteger = exports.validateNumberRange = exports.validateArrayInput = exports.validateExtensionInput = exports.extend = exports.extendAll = exports.withCache = void 0;
+exports.initializeExtensions = initializeExtensions;
+// Import types first
+require("../types/global-augmentations");
+const array_1 = require("./array");
+const number_1 = require("./number");
+const object_1 = require("./object");
+// Import extension modules
+const string_1 = require("./string");
+// Import core utilities
+const performance_1 = require("./core/performance");
+Object.defineProperty(exports, "LRUCache", { enumerable: true, get: function () { return performance_1.LRUCache; } });
+Object.defineProperty(exports, "getPerformanceConfig", { enumerable: true, get: function () { return performance_1.getPerformanceConfig; } });
+Object.defineProperty(exports, "setPerformanceConfig", { enumerable: true, get: function () { return performance_1.setPerformanceConfig; } });
+Object.defineProperty(exports, "withCache", { enumerable: true, get: function () { return performance_1.withCache; } });
+// Import validation utilities
+const validation_1 = require("./core/validation");
+Object.defineProperty(exports, "validateArrayInput", { enumerable: true, get: function () { return validation_1.validateArrayInput; } });
+Object.defineProperty(exports, "validateExtensionInput", { enumerable: true, get: function () { return validation_1.validateExtensionInput; } });
+Object.defineProperty(exports, "validateNumberRange", { enumerable: true, get: function () { return validation_1.validateNumberRange; } });
+Object.defineProperty(exports, "validatePositiveInteger", { enumerable: true, get: function () { return validation_1.validatePositiveInteger; } });
+// Import utility functions
+const config_1 = require("./utils/config");
+Object.defineProperty(exports, "mergeConfigs", { enumerable: true, get: function () { return config_1.mergeConfigs; } });
+Object.defineProperty(exports, "validateConfig", { enumerable: true, get: function () { return config_1.validateConfig; } });
+Object.defineProperty(exports, "validatePerformanceSettings", { enumerable: true, get: function () { return config_1.validatePerformanceSettings; } });
+const helpers_1 = require("./utils/helpers");
+Object.defineProperty(exports, "ensurePositiveInteger", { enumerable: true, get: function () { return helpers_1.ensurePositiveInteger; } });
+Object.defineProperty(exports, "getPathSegments", { enumerable: true, get: function () { return helpers_1.getPathSegments; } });
+Object.defineProperty(exports, "hasOwnProperty", { enumerable: true, get: function () { return helpers_1.hasOwnProperty; } });
+Object.defineProperty(exports, "isValidArrayIndex", { enumerable: true, get: function () { return helpers_1.isValidArrayIndex; } });
+Object.defineProperty(exports, "safeClone", { enumerable: true, get: function () { return helpers_1.safeClone; } });
+// Import initialization functions
+const initializer_1 = require("./init/initializer");
+Object.defineProperty(exports, "extendAll", { enumerable: true, get: function () { return initializer_1.extendAll; } });
+/**
+ * Initialize JavaScript prototype extensions
+ * @param options - Configure which extensions to enable (default: all enabled)
+ */
+function initializeExtensions(options = {}) {
+    (0, initializer_1.initExtensions)(options);
+}
+/**
+ * Selective prototype extension helpers
+ * Initialize only specific extensions
+ */
+exports.extend = {
+    string: string_1.extendString,
+    array: array_1.extendArray,
+    object: object_1.extendObject,
+    number: number_1.extendNumber,
+};
+// Default export
+exports.default = {
+    initializeExtensions,
+    extendAll: initializer_1.extendAll,
+    extend: exports.extend,
+    LRUCache: performance_1.LRUCache,
+    setPerformanceConfig: performance_1.setPerformanceConfig,
+    getPerformanceConfig: performance_1.getPerformanceConfig,
+    // Validation utilities
+    validateExtensionInput: validation_1.validateExtensionInput,
+    validateArrayInput: validation_1.validateArrayInput,
+    validateNumberRange: validation_1.validateNumberRange,
+    validatePositiveInteger: validation_1.validatePositiveInteger,
+    // Utility functions
+    validateConfig: config_1.validateConfig,
+    validatePerformanceSettings: config_1.validatePerformanceSettings,
+    mergeConfigs: config_1.mergeConfigs,
+    isValidArrayIndex: helpers_1.isValidArrayIndex,
+    ensurePositiveInteger: helpers_1.ensurePositiveInteger,
+    safeClone: helpers_1.safeClone,
+    getPathSegments: helpers_1.getPathSegments,
+    hasOwnProperty: helpers_1.hasOwnProperty,
+};

package/dist/cjs/init/index.d.ts

@@ -0,0 +1,2 @@
+export * from './initializer';
+export * from './options';

package/dist/cjs/init/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export initialization logic
+__exportStar(require("./initializer"), exports);
+__exportStar(require("./options"), exports);

package/dist/cjs/init/initializer.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionOptions } from '../types/extension-types';
+export declare function initExtensions(options?: ExtensionOptions): void;
+export declare function extendAll(): void;

package/dist/cjs/init/initializer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initExtensions = initExtensions;
+exports.extendAll = extendAll;
+// Extension initialization logic
+const array_1 = require("../array");
+const performance_1 = require("../core/performance");
+const number_1 = require("../number");
+const object_1 = require("../object");
+const string_1 = require("../string");
+function initExtensions(options = {}) {
+    const { string = true, array = true, object = true, number = true, performance, } = options;
+    if (performance) {
+        // Set performance config if provided
+        (0, performance_1.setPerformanceConfig)(performance);
+    }
+    if (string)
+        (0, string_1.extendString)();
+    if (array)
+        (0, array_1.extendArray)();
+    if (object)
+        (0, object_1.extendObject)();
+    if (number)
+        (0, number_1.extendNumber)();
+}
+function extendAll() {
+    initExtensions();
+}

package/dist/cjs/init/options.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionOptions } from '../types/extension-types';
+export declare function validateExtensionOptions(options: Partial<ExtensionOptions>): ExtensionOptions;
+export declare function createExtensionOptions(enableString?: boolean, enableArray?: boolean, enableObject?: boolean, enableNumber?: boolean, performanceConfig?: any): ExtensionOptions;

package/dist/cjs/init/options.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExtensionOptions = validateExtensionOptions;
+exports.createExtensionOptions = createExtensionOptions;
+function validateExtensionOptions(options) {
+    const validated = {
+        string: options.string !== false,
+        array: options.array !== false,
+        object: options.object !== false,
+        number: options.number !== false,
+        performance: options.performance,
+    };
+    return validated;
+}
+function createExtensionOptions(enableString = true, enableArray = true, enableObject = true, enableNumber = true, performanceConfig) {
+    return {
+        string: enableString,
+        array: enableArray,
+        object: enableObject,
+        number: enableNumber,
+        performance: performanceConfig,
+    };
+}

package/dist/cjs/number/index.d.ts

@@ -0,0 +1 @@
+export { extendNumber } from './number-extensions';

package/dist/cjs/number/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendNumber = void 0;
+var number_extensions_1 = require("./number-extensions");
+Object.defineProperty(exports, "extendNumber", { enumerable: true, get: function () { return number_extensions_1.extendNumber; } });

package/dist/cjs/number/number-extensions.d.ts

@@ -0,0 +1 @@
+export declare function extendNumber(): void;

package/dist/cjs/number/number-extensions.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendNumber = extendNumber;
+const utils_1 = require("src/utils");
+const performance_1 = require("../core/performance");
+let numberExtended = false;
+function extendNumber() {
+    if (numberExtended)
+        return;
+    numberExtended = true;
+    (0, utils_1.defineExtension)(Number.prototype, 'toPercent', function (decimals = 2) {
+        return `${(this * 100).toFixed(decimals)}%`;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'toCurrency', function (currency = 'USD', locale = 'en-US') {
+        return new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency,
+        }).format(this);
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'clamp', function (min, max) {
+        if (min > max)
+            throw new RangeError(`clamp: min (${min}) cannot be greater than max (${max})`);
+        return Math.min(Math.max(this, min), max);
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'isEven', function () {
+        return this % 2 === 0;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'isOdd', function () {
+        return this % 2 !== 0;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'isPrime', function () {
+        const num = this;
+        return (0, performance_1.withCache)((0, performance_1.makeInternalCacheKey)('prime', num), () => {
+            if (num < 2)
+                return false;
+            for (let i = 2; i <= Math.sqrt(num); i++)
+                if (num % i === 0)
+                    return false;
+            return true;
+        });
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'factorial', function () {
+        const num = Math.floor(this);
+        return (0, performance_1.withCache)((0, performance_1.makeInternalCacheKey)('factorial', num), () => {
+            if (num < 0)
+                return NaN;
+            if (num <= 1)
+                return 1;
+            let result = 1;
+            for (let i = 2; i <= num; i++)
+                result *= i;
+            return result;
+        });
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'toOrdinal', function () {
+        const num = Math.floor(this);
+        const suffix = ['th', 'st', 'nd', 'rd'];
+        const v = num % 100;
+        return num + (suffix[(v - 20) % 10] || suffix[v] || suffix[0]);
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'toRoman', function () {
+        const num = Math.floor(this);
+        if (num <= 0)
+            throw new RangeError('toRoman: number must be positive');
+        if (num >= 4000)
+            throw new RangeError('toRoman: number must be less than 4000');
+        return (0, performance_1.withCache)((0, performance_1.makeInternalCacheKey)('roman', num), () => {
+            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 n = num;
+            let result = '';
+            for (let i = 0; i < values.length; i++) {
+                while (n >= values[i]) {
+                    result += symbols[i];
+                    n -= values[i];
+                }
+            }
+            return result;
+        });
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'inRange', function (min, max) {
+        return this >= min && this <= max;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'round', function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0)
+            throw new TypeError('round: decimals must be non-negative integer');
+        const factor = Math.pow(10, decimals);
+        return Math.round(this * factor) / factor;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'ceil', function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0)
+            throw new TypeError('ceil: decimals must be non-negative integer');
+        const factor = Math.pow(10, decimals);
+        return Math.ceil(this * factor) / factor;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'floor', function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0)
+            throw new TypeError('floor: decimals must be non-negative integer');
+        const factor = Math.pow(10, decimals);
+        return Math.floor(this * factor) / factor;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'abs', function () {
+        return Math.abs(this);
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'sign', function () {
+        return Math.sign(this);
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'times', function (callback) {
+        if (typeof callback !== 'function')
+            throw new TypeError('times: callback must be a function');
+        for (let i = 0; i < Math.floor(this); i++)
+            callback(i);
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'toFixedNumber', function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0) {
+            throw new TypeError(`toFixedNumber: decimals must be a non-negative integer, got ${decimals}`);
+        }
+        const factor = Math.pow(10, decimals);
+        return Math.round(this.valueOf() * factor) / factor;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'randomUpTo', function () {
+        const max = this.valueOf();
+        if (!Number.isFinite(max)) {
+            throw new TypeError(`randomUpTo: number must be finite, got ${max}`);
+        }
+        return Math.random() * max;
+    });
+}

package/dist/cjs/object/index.d.ts

@@ -0,0 +1 @@
+export { extendObject } from './object-extensions';

package/dist/cjs/object/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendObject = void 0;
+var object_extensions_1 = require("./object-extensions");
+Object.defineProperty(exports, "extendObject", { enumerable: true, get: function () { return object_extensions_1.extendObject; } });

package/dist/cjs/object/object-extensions.d.ts

@@ -0,0 +1 @@
+export declare function extendObject(): void;

package/dist/cjs/object/object-extensions.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendObject = extendObject;
+const utils_1 = require("src/utils");
+let objectExtended = false;
+function extendObject() {
+    if (objectExtended)
+        return;
+    objectExtended = true;
+    (0, utils_1.defineExtension)(Object.prototype, 'isEmpty', function () {
+        return Object.keys(this).length === 0;
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'pick', function (keys) {
+        if (!Array.isArray(keys))
+            throw new TypeError('pick: keys must be an array');
+        if (!keys.length)
+            throw new TypeError('pick: keys array cannot be empty');
+        const result = {};
+        keys.forEach((key) => {
+            if (key in this)
+                result[key] = this[key];
+        });
+        return result;
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'omit', function (keys) {
+        if (!Array.isArray(keys))
+            throw new TypeError('omit: keys must be an array');
+        if (!keys.length)
+            throw new TypeError('omit: keys array cannot be empty');
+        const result = { ...this };
+        keys.forEach((key) => delete result[key]);
+        return result;
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'deepClone', function () {
+        const visited = new WeakSet();
+        function deepCloneSafe(obj) {
+            if (obj === null || typeof obj !== 'object')
+                return obj;
+            if (visited.has(obj))
+                throw new Error('Circular reference detected in deepClone');
+            visited.add(obj);
+            if (obj instanceof Date)
+                return new Date(obj.getTime());
+            if (Array.isArray(obj))
+                return obj.map((item) => deepCloneSafe(item));
+            const cloned = {};
+            Object.keys(obj).forEach((key) => {
+                cloned[key] = deepCloneSafe(obj[key]);
+            });
+            return cloned;
+        }
+        return deepCloneSafe(this);
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'merge', function (other) {
+        return { ...this, ...other };
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'deepFreeze', function () {
+        Object.getOwnPropertyNames(this).forEach((name) => {
+            const value = this[name];
+            if (value && typeof value === 'object')
+                value.deepFreeze?.();
+        });
+        return Object.freeze(this);
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'hasPath', function (path) {
+        if (!path.trim())
+            throw new TypeError('hasPath: path cannot be empty');
+        let current = this;
+        return path.split('.').every((key) => {
+            if (current == null || !(key in current))
+                return false;
+            current = current[key];
+            return true;
+        });
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'getPath', function (path, defaultValue) {
+        if (!path.trim())
+            throw new TypeError('getPath: path cannot be empty');
+        return path
+            .split('.')
+            .reduce((acc, key) => (acc && key in acc ? acc[key] : defaultValue), this);
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'setPath', function (path, value) {
+        if (!path.trim())
+            throw new TypeError('setPath: path cannot be empty');
+        const keys = path.split('.');
+        let current = this;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!(keys[i] in current) || typeof current[keys[i]] !== 'object')
+                current[keys[i]] = {};
+            current = current[keys[i]];
+        }
+        current[keys[keys.length - 1]] = value;
+        return this;
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'mapValues', function (fn) {
+        if (typeof fn !== 'function') {
+            throw new TypeError(`mapValues: fn must be a function, got ${typeof fn}`);
+        }
+        const result = {};
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                result[key] = fn(this[key], key);
+            }
+        }
+        return result;
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'mapKeys', function (fn) {
+        if (typeof fn !== 'function') {
+            throw new TypeError(`mapKeys: fn must be a function, got ${typeof fn}`);
+        }
+        const result = {};
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const newKey = fn(key);
+                result[newKey] = this[key];
+            }
+        }
+        return result;
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'filterKeys', function (keys) {
+        if (!Array.isArray(keys)) {
+            throw new TypeError(`filterKeys: keys must be an array, got ${typeof keys}`);
+        }
+        const result = {};
+        for (const key of keys) {
+            if (key in this) {
+                result[key] = this[key];
+            }
+        }
+        return result;
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'filterValues', function (fn) {
+        if (typeof fn !== 'function') {
+            throw new TypeError(`filterValues: fn must be a function, got ${typeof fn}`);
+        }
+        const result = {};
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const val = this[key];
+                if (fn(val, key)) {
+                    result[key] = val;
+                }
+            }
+        }
+        return result;
+    });
+}

package/dist/cjs/string/index.d.ts

@@ -0,0 +1 @@
+export { extendString } from './string-extensions';

package/dist/cjs/string/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendString = void 0;
+var string_extensions_1 = require("./string-extensions");
+Object.defineProperty(exports, "extendString", { enumerable: true, get: function () { return string_extensions_1.extendString; } });

package/dist/cjs/string/string-extensions.d.ts

@@ -0,0 +1 @@
+export declare function extendString(): void;

package/dist/cjs/string/string-extensions.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendString = extendString;
+const utils_1 = require("src/utils");
+let stringExtended = false;
+function extendString() {
+    if (stringExtended)
+        return;
+    stringExtended = true;
+    (0, utils_1.defineExtension)(String.prototype, 'toCapitalize', function () {
+        return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'toCamelCase', function () {
+        return this.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : '');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'toKebabCase', function () {
+        return this.replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase();
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'toSnakeCase', function () {
+        return this.replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/[\s-]+/g, '_')
+            .toLowerCase();
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'truncate', function (length, suffix = '...') {
+        if (!Number.isInteger(length) || length < 0) {
+            throw new TypeError(`truncate: length must be a non-negative integer, got ${length}`);
+        }
+        return this.length > length
+            ? this.substring(0, length) + suffix
+            : this.toString();
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'isEmail', function () {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(this.toString());
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'isUrl', function () {
+        try {
+            new URL(this.toString());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'removeWhitespace', function () {
+        return this.replace(/\s+/g, '');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'reverse', function () {
+        return this.split('').reverse().join('');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'isPalindrome', function () {
+        const cleaned = this.toLowerCase().replace(/[^a-z0-9]/g, '');
+        return cleaned === cleaned.split('').reverse().join('');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'toTitleCase', function () {
+        return this.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'stripHtml', function () {
+        return this.replace(/<[^>]*>/g, '');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'padStart', function (targetLength, padString = ' ') {
+        if (!Number.isInteger(targetLength) || targetLength < 0) {
+            throw new TypeError(`padStart: targetLength must be a non-negative integer, got ${targetLength}`);
+        }
+        if (typeof padString !== 'string') {
+            throw new TypeError(`padStart: padString must be a string, got ${typeof padString}`);
+        }
+        if (padString.length === 0) {
+            throw new TypeError('padStart: padString cannot be empty');
+        }
+        return this.toString().padStart(targetLength, padString);
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'padEnd', function (targetLength, padString = ' ') {
+        if (!Number.isInteger(targetLength) || targetLength < 0) {
+            throw new TypeError(`padEnd: targetLength must be a non-negative integer, got ${targetLength}`);
+        }
+        if (typeof padString !== 'string') {
+            throw new TypeError(`padEnd: padString must be a string, got ${typeof padString}`);
+        }
+        if (padString.length === 0) {
+            throw new TypeError('padEnd: padString cannot be empty');
+        }
+        return this.toString().padEnd(targetLength, padString);
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'count', function (substring) {
+        if (typeof substring !== 'string') {
+            throw new TypeError(`count: substring must be a string, got ${typeof substring}`);
+        }
+        if (substring === '') {
+            throw new TypeError('count: substring cannot be empty');
+        }
+        const escaped = substring.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return (this.match(new RegExp(escaped, 'g')) || []).length;
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'words', function () {
+        return this.trim()
+            .split(/\s+/)
+            .filter((word) => word.length > 0);
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'lines', function () {
+        return this.split(/\r?\n/);
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'capitalizeWords', function () {
+        return this.toString().replace(/\b\w/g, (char) => char.toUpperCase());
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'reverseWords', function () {
+        return this.toString().split(/\s+/).reverse().join(' ');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'truncateWords', function (count, suffix = '...') {
+        if (!Number.isInteger(count) || count < 0) {
+            throw new TypeError(`truncateWords: count must be a non-negative integer, got ${count}`);
+        }
+        const words = this.toString().split(/\s+/);
+        if (words.length <= count)
+            return this.toString();
+        return words.slice(0, count).join(' ') + suffix;
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'slugify', function () {
+        return this.toString()
+            .toLowerCase()
+            .replace(/[^\w\s-]/g, '')
+            .trim()
+            .replace(/[\s_-]+/g, '-');
+    });
+}

package/dist/cjs/types/extension-types.d.ts

@@ -0,0 +1,9 @@
+import { PerformanceConfig } from '../core/performance';
+export interface ExtensionOptions {
+    string?: boolean;
+    array?: boolean;
+    object?: boolean;
+    number?: boolean;
+    performance?: PerformanceConfig;
+}
+export { PerformanceConfig };

package/dist/cjs/types/extension-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });