@naman_deep_singh/js-extensions 1.0.0

package/README.md

@@ -0,0 +1,89 @@
+# @naman_deep_singh/js-extensions
+
+Universal JavaScript prototype extensions for common development utilities. Works in both Node.js and browser environments.
+
+## Installation
+
+```bash
+npm install @naman_deep_singh/js-extensions
+# or
+pnpm add @naman_deep_singh/js-extensions
+```
+
+## Usage
+
+### Initialize All Extensions
+
+```typescript
+import { initExtensions } from '@naman_deep_singh/js-extensions';
+
+// Initialize all extensions
+initExtensions();
+
+// Now use the extensions
+"hello world".toCapitalize(); // "Hello world"
+[1, 2, 2, 3].unique(); // [1, 2, 3]
+```
+
+### Selective Extensions
+
+```typescript
+import { extend } from '@naman_deep_singh/js-extensions';
+
+// Only extend strings
+extend.string();
+
+// Only extend arrays and objects
+initExtensions({ array: true, object: true, string: false, number: false });
+```
+
+## String Extensions
+
+- `toCapitalize()` - Capitalize first letter
+- `toCamelCase()` - Convert to camelCase
+- `toKebabCase()` - Convert to kebab-case
+- `toSnakeCase()` - Convert to snake_case
+- `truncate(length, suffix?)` - Truncate with optional suffix
+- `isEmail()` - Check if valid email
+- `isUrl()` - Check if valid URL
+- `removeWhitespace()` - Remove all whitespace
+- `reverse()` - Reverse string
+
+## Array Extensions
+
+- `unique()` - Remove duplicates
+- `shuffle()` - Randomly shuffle array
+- `chunk(size)` - Split into chunks
+- `groupBy(keyFn)` - Group by key function
+- `sum()` - Sum numeric values
+- `average()` - Calculate average
+- `compact()` - Remove falsy values
+- `pluck(key)` - Extract property values
+
+## Object Extensions
+
+- `isEmpty()` - Check if object is empty
+- `pick(keys)` - Pick specific keys
+- `omit(keys)` - Omit specific keys
+- `deepClone()` - Deep clone object
+- `merge(other)` - Merge with another object
+
+## Number Extensions
+
+- `toPercent(decimals?)` - Convert to percentage string
+- `toCurrency(currency?, locale?)` - Format as currency
+- `clamp(min, max)` - Clamp between min/max
+- `isEven()` - Check if even
+- `isOdd()` - Check if odd
+- `isPrime()` - Check if prime number
+- `factorial()` - Calculate factorial
+
+## Browser Usage
+
+```html
+<script src="path/to/js-extensions.js"></script>
+<script>
+  // Extensions are automatically initialized
+  console.log("hello".toCapitalize()); // "Hello"
+</script>
+```

package/dist/array-extensions.d.ts

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

package/dist/array-extensions.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendArray = extendArray;
+// Array prototype extensions
+function extendArray() {
+    Array.prototype.unique = function () {
+        return [...new Set(this)];
+    };
+    Array.prototype.shuffle = function () {
+        const arr = [...this];
+        for (let i = arr.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        }
+        return arr;
+    };
+    Array.prototype.chunk = function (size) {
+        const chunks = [];
+        for (let i = 0; i < this.length; i += size) {
+            chunks.push(this.slice(i, i + size));
+        }
+        return chunks;
+    };
+    Array.prototype.groupBy = function (keyFn) {
+        return this.reduce((groups, item) => {
+            const key = keyFn(item);
+            if (!groups[key])
+                groups[key] = [];
+            groups[key].push(item);
+            return groups;
+        }, {});
+    };
+    Array.prototype.sum = function () {
+        return this.reduce((sum, num) => sum + (typeof num === 'number' ? num : 0), 0);
+    };
+    Array.prototype.average = function () {
+        const numbers = this.filter(item => typeof item === 'number');
+        return numbers.length > 0 ? numbers.reduce((sum, num) => sum + num, 0) / numbers.length : 0;
+    };
+    Array.prototype.compact = function () {
+        return this.filter(item => item != null && item !== '' && item !== false);
+    };
+    Array.prototype.pluck = function (key) {
+        return this.map(item => item && typeof item === 'object' ? item[key] : undefined).filter(val => val !== undefined);
+    };
+    Array.prototype.findLast = function (predicate) {
+        for (let i = this.length - 1; i >= 0; i--) {
+            if (predicate(this[i]))
+                return this[i];
+        }
+        return undefined;
+    };
+    Array.prototype.partition = function (predicate) {
+        const truthy = [];
+        const falsy = [];
+        this.forEach(item => predicate(item) ? truthy.push(item) : falsy.push(item));
+        return [truthy, falsy];
+    };
+    Array.prototype.flatten = function (depth = 1) {
+        return depth > 0 ? this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.flatten(depth - 1) : val), []) : this.slice();
+    };
+    Array.prototype.deepFlatten = function () {
+        return this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.deepFlatten() : val), []);
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import { extendString } from './string-extensions';
+import { extendArray } from './array-extensions';
+import { extendObject } from './object-extensions';
+import { extendNumber } from './number-extensions';
+import './types';
+export interface ExtensionOptions {
+    string?: boolean;
+    array?: boolean;
+    object?: boolean;
+    number?: boolean;
+}
+/**
+ * Initialize JavaScript prototype extensions
+ * @param options - Configure which extensions to enable (default: all enabled)
+ */
+export declare function initExtensions(options?: ExtensionOptions): void;
+/**
+ * Initialize all extensions (convenience function)
+ */
+export declare function extendAll(): void;
+/**
+ * Initialize only specific extensions
+ */
+export declare const extend: {
+    string: typeof extendString;
+    array: typeof extendArray;
+    object: typeof extendObject;
+    number: typeof extendNumber;
+};
+declare const _default: {
+    initExtensions: typeof initExtensions;
+    extendAll: typeof extendAll;
+    extend: {
+        string: typeof extendString;
+        array: typeof extendArray;
+        object: typeof extendObject;
+        number: typeof extendNumber;
+    };
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extend = void 0;
+exports.initExtensions = initExtensions;
+exports.extendAll = extendAll;
+const string_extensions_1 = require("./string-extensions");
+const array_extensions_1 = require("./array-extensions");
+const object_extensions_1 = require("./object-extensions");
+const number_extensions_1 = require("./number-extensions");
+require("./types");
+/**
+ * Initialize JavaScript prototype extensions
+ * @param options - Configure which extensions to enable (default: all enabled)
+ */
+function initExtensions(options = {}) {
+    const { string = true, array = true, object = true, number = true } = options;
+    if (string)
+        (0, string_extensions_1.extendString)();
+    if (array)
+        (0, array_extensions_1.extendArray)();
+    if (object)
+        (0, object_extensions_1.extendObject)();
+    if (number)
+        (0, number_extensions_1.extendNumber)();
+}
+/**
+ * Initialize all extensions (convenience function)
+ */
+function extendAll() {
+    initExtensions();
+}
+/**
+ * Initialize only specific extensions
+ */
+exports.extend = {
+    string: string_extensions_1.extendString,
+    array: array_extensions_1.extendArray,
+    object: object_extensions_1.extendObject,
+    number: number_extensions_1.extendNumber
+};
+exports.default = {
+    initExtensions,
+    extendAll,
+    extend: exports.extend
+};

package/dist/number-extensions.d.ts

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

package/dist/number-extensions.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendNumber = extendNumber;
+// Number prototype extensions
+function extendNumber() {
+    Number.prototype.toPercent = function (decimals = 2) {
+        return (this.valueOf() * 100).toFixed(decimals) + '%';
+    };
+    Number.prototype.toCurrency = function (currency = 'USD', locale = 'en-US') {
+        return new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency: currency
+        }).format(this.valueOf());
+    };
+    Number.prototype.clamp = function (min, max) {
+        return Math.min(Math.max(this.valueOf(), min), max);
+    };
+    Number.prototype.isEven = function () {
+        return this.valueOf() % 2 === 0;
+    };
+    Number.prototype.isOdd = function () {
+        return this.valueOf() % 2 !== 0;
+    };
+    Number.prototype.isPrime = function () {
+        const num = this.valueOf();
+        if (num < 2)
+            return false;
+        for (let i = 2; i <= Math.sqrt(num); i++) {
+            if (num % i === 0)
+                return false;
+        }
+        return true;
+    };
+    Number.prototype.factorial = function () {
+        const num = Math.floor(this.valueOf());
+        if (num < 0)
+            return NaN;
+        if (num === 0 || num === 1)
+            return 1;
+        let result = 1;
+        for (let i = 2; i <= num; i++) {
+            result *= i;
+        }
+        return result;
+    };
+    Number.prototype.toOrdinal = function () {
+        const num = Math.floor(this.valueOf());
+        const suffix = ['th', 'st', 'nd', 'rd'];
+        const v = num % 100;
+        return num + (suffix[(v - 20) % 10] || suffix[v] || suffix[0]);
+    };
+    Number.prototype.toRoman = function () {
+        const num = Math.floor(this.valueOf());
+        if (num <= 0 || num >= 4000)
+            return num.toString();
+        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 n = num;
+        for (let i = 0; i < values.length; i++) {
+            while (n >= values[i]) {
+                result += symbols[i];
+                n -= values[i];
+            }
+        }
+        return result;
+    };
+    Number.prototype.inRange = function (min, max) {
+        const num = this.valueOf();
+        return num >= min && num <= max;
+    };
+}

package/dist/object-extensions.d.ts

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

package/dist/object-extensions.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendObject = extendObject;
+// Object prototype extensions
+function extendObject() {
+    Object.prototype.isEmpty = function () {
+        return Object.keys(this).length === 0;
+    };
+    Object.prototype.pick = function (keys) {
+        const result = {};
+        const obj = this;
+        keys.forEach(key => {
+            if (key in obj) {
+                result[key] = obj[key];
+            }
+        });
+        return result;
+    };
+    Object.prototype.omit = function (keys) {
+        const result = { ...this };
+        keys.forEach(key => {
+            delete result[key];
+        });
+        return result;
+    };
+    Object.prototype.deepClone = function () {
+        if (this === null || typeof this !== 'object')
+            return this;
+        if (this instanceof Date)
+            return new Date(this.getTime());
+        if (this instanceof Array)
+            return this.map(item => item?.deepClone?.() || item);
+        const cloned = {};
+        Object.keys(this).forEach(key => {
+            const value = this[key];
+            cloned[key] = value?.deepClone?.() || value;
+        });
+        return cloned;
+    };
+    Object.prototype.merge = function (other) {
+        return { ...this, ...other };
+    };
+    Object.prototype.deepFreeze = function () {
+        const propNames = Object.getOwnPropertyNames(this);
+        for (const name of propNames) {
+            const value = this[name];
+            if (value && typeof value === 'object') {
+                value.deepFreeze();
+            }
+        }
+        return Object.freeze(this);
+    };
+}

package/dist/string-extensions.d.ts

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

package/dist/string-extensions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendString = extendString;
+// String prototype extensions
+function extendString() {
+    String.prototype.toCapitalize = function () {
+        return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
+    };
+    String.prototype.toCamelCase = function () {
+        return this.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : '');
+    };
+    String.prototype.toKebabCase = function () {
+        return this.replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase();
+    };
+    String.prototype.toSnakeCase = function () {
+        return this.replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/[\s-]+/g, '_')
+            .toLowerCase();
+    };
+    String.prototype.truncate = function (length, suffix = '...') {
+        return this.length > length ? this.substring(0, length) + suffix : this.toString();
+    };
+    String.prototype.isEmail = function () {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(this.toString());
+    };
+    String.prototype.isUrl = function () {
+        try {
+            new URL(this.toString());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    String.prototype.removeWhitespace = function () {
+        return this.replace(/\s+/g, '');
+    };
+    String.prototype.reverse = function () {
+        return this.split('').reverse().join('');
+    };
+    String.prototype.isPalindrome = function () {
+        const cleaned = this.toLowerCase().replace(/[^a-z0-9]/g, '');
+        return cleaned === cleaned.split('').reverse().join('');
+    };
+    String.prototype.toTitleCase = function () {
+        return this.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
+    };
+    String.prototype.stripHtml = function () {
+        return this.replace(/<[^>]*>/g, '');
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+declare global {
+    interface String {
+        toCapitalize(): string;
+        toCamelCase(): string;
+        toKebabCase(): string;
+        toSnakeCase(): string;
+        truncate(length: number, suffix?: string): string;
+        isEmail(): boolean;
+        isUrl(): boolean;
+        removeWhitespace(): string;
+        reverse(): string;
+        isPalindrome(): boolean;
+        toTitleCase(): string;
+        stripHtml(): string;
+    }
+    interface Array<T> {
+        unique(): T[];
+        shuffle(): T[];
+        chunk(size: number): T[][];
+        groupBy<K extends string | number>(keyFn: (item: T) => K): Record<K, T[]>;
+        sum(): number;
+        average(): number;
+        compact(): T[];
+        pluck<K extends keyof T>(key: K): T[K][];
+        findLast(predicate: (item: T) => boolean): T | undefined;
+        partition(predicate: (item: T) => boolean): [T[], T[]];
+        flatten(depth?: number): any[];
+        deepFlatten(): any[];
+    }
+    interface Object {
+        isEmpty(): boolean;
+        pick<T extends Record<string, any>, K extends keyof T>(keys: K[]): Pick<T, K>;
+        omit<T extends Record<string, any>, K extends keyof T>(keys: K[]): Omit<T, K>;
+        deepClone<T>(): T;
+        merge(other: Record<string, any>): Record<string, any>;
+        deepFreeze<T>(): T;
+    }
+    interface Number {
+        toPercent(decimals?: number): string;
+        toCurrency(currency?: string, locale?: string): string;
+        clamp(min: number, max: number): number;
+        isEven(): boolean;
+        isOdd(): boolean;
+        isPrime(): boolean;
+        factorial(): number;
+        toOrdinal(): string;
+        toRoman(): string;
+        inRange(min: number, max: number): boolean;
+    }
+}
+export {};

package/dist/types.js

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

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@naman_deep_singh/js-extensions",
+  "version": "1.0.0",
+  "description": "Universal JavaScript prototype extensions for common development utilities",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "browser": "dist/index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "javascript",
+    "utilities",
+    "extensions",
+    "prototype",
+    "string",
+    "array",
+    "object",
+    "universal"
+  ],
+  "author": "Naman Deep Singh",
+  "license": "ISC",
+  "packageManager": "pnpm@10.20.0",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/src/array-extensions.ts

@@ -0,0 +1,73 @@
+// Array prototype extensions
+export function extendArray() {
+  Array.prototype.unique = function<T>(): T[] {
+    return [...new Set(this)];
+  };
+
+  Array.prototype.shuffle = function<T>(): T[] {
+    const arr = [...this];
+    for (let i = arr.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+    return arr;
+  };
+
+  Array.prototype.chunk = function<T>(size: number): T[][] {
+    const chunks: T[][] = [];
+    for (let i = 0; i < this.length; i += size) {
+      chunks.push(this.slice(i, i + size));
+    }
+    return chunks;
+  };
+
+  Array.prototype.groupBy = function<T>(keyFn: (item: T) => string | number): Record<string | number, T[]> {
+    return this.reduce((groups, item) => {
+      const key = keyFn(item);
+      if (!groups[key]) groups[key] = [];
+      groups[key].push(item);
+      return groups;
+    }, {} as Record<string | number, T[]>);
+  };
+
+  Array.prototype.sum = function(): number {
+    return this.reduce((sum, num) => sum + (typeof num === 'number' ? num : 0), 0);
+  };
+
+  Array.prototype.average = function(): number {
+    const numbers = this.filter(item => typeof item === 'number');
+    return numbers.length > 0 ? numbers.reduce((sum, num) => sum + num, 0) / numbers.length : 0;
+  };
+
+  Array.prototype.compact = function<T>(): T[] {
+    return this.filter(item => item != null && item !== '' && item !== false);
+  };
+
+  Array.prototype.pluck = function<T, K extends keyof T>(key: K): T[K][] {
+    return this.map(item => item && typeof item === 'object' ? item[key] : undefined).filter(val => val !== undefined);
+  };
+
+  Array.prototype.findLast = function<T>(predicate: (item: T) => boolean): T | undefined {
+    for (let i = this.length - 1; i >= 0; i--) {
+      if (predicate(this[i])) return this[i];
+    }
+    return undefined;
+  };
+
+  Array.prototype.partition = function<T>(predicate: (item: T) => boolean): [T[], T[]] {
+    const truthy: T[] = [];
+    const falsy: T[] = [];
+    this.forEach(item => predicate(item) ? truthy.push(item) : falsy.push(item));
+    return [truthy, falsy];
+  };
+
+  Array.prototype.flatten = function(depth: number = 1): any[] {
+    return depth > 0 ? this.reduce((acc, val) => 
+      acc.concat(Array.isArray(val) ? val.flatten(depth - 1) : val), []) : this.slice();
+  };
+
+  Array.prototype.deepFlatten = function(): any[] {
+    return this.reduce((acc, val) => 
+      acc.concat(Array.isArray(val) ? val.deepFlatten() : val), []);
+  };
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+import { extendString } from './string-extensions';
+import { extendArray } from './array-extensions';
+import { extendObject } from './object-extensions';
+import { extendNumber } from './number-extensions';
+import './types';
+
+export interface ExtensionOptions {
+  string?: boolean;
+  array?: boolean;
+  object?: boolean;
+  number?: boolean;
+}
+
+/**
+ * Initialize JavaScript prototype extensions
+ * @param options - Configure which extensions to enable (default: all enabled)
+ */
+export function initExtensions(options: ExtensionOptions = {}): void {
+  const {
+    string = true,
+    array = true,
+    object = true,
+    number = true
+  } = options;
+
+  if (string) extendString();
+  if (array) extendArray();
+  if (object) extendObject();
+  if (number) extendNumber();
+}
+
+/**
+ * Initialize all extensions (convenience function)
+ */
+export function extendAll(): void {
+  initExtensions();
+}
+
+/**
+ * Initialize only specific extensions
+ */
+export const extend = {
+  string: extendString,
+  array: extendArray,
+  object: extendObject,
+  number: extendNumber
+};
+
+
+
+export default {
+  initExtensions,
+  extendAll,
+  extend
+};

package/src/number-extensions.ts

@@ -0,0 +1,73 @@
+// Number prototype extensions
+export function extendNumber() {
+  Number.prototype.toPercent = function(decimals: number = 2): string {
+    return (this.valueOf() * 100).toFixed(decimals) + '%';
+  };
+
+  Number.prototype.toCurrency = function(currency: string = 'USD', locale: string = 'en-US'): string {
+    return new Intl.NumberFormat(locale, {
+      style: 'currency',
+      currency: currency
+    }).format(this.valueOf());
+  };
+
+  Number.prototype.clamp = function(min: number, max: number): number {
+    return Math.min(Math.max(this.valueOf(), min), max);
+  };
+
+  Number.prototype.isEven = function(): boolean {
+    return this.valueOf() % 2 === 0;
+  };
+
+  Number.prototype.isOdd = function(): boolean {
+    return this.valueOf() % 2 !== 0;
+  };
+
+  Number.prototype.isPrime = function(): boolean {
+    const num = this.valueOf();
+    if (num < 2) return false;
+    for (let i = 2; i <= Math.sqrt(num); i++) {
+      if (num % i === 0) return false;
+    }
+    return true;
+  };
+
+  Number.prototype.factorial = function(): number {
+    const num = Math.floor(this.valueOf());
+    if (num < 0) return NaN;
+    if (num === 0 || num === 1) return 1;
+    let result = 1;
+    for (let i = 2; i <= num; i++) {
+      result *= i;
+    }
+    return result;
+  };
+
+  Number.prototype.toOrdinal = function(): string {
+    const num = Math.floor(this.valueOf());
+    const suffix = ['th', 'st', 'nd', 'rd'];
+    const v = num % 100;
+    return num + (suffix[(v - 20) % 10] || suffix[v] || suffix[0]);
+  };
+
+  Number.prototype.toRoman = function(): string {
+    const num = Math.floor(this.valueOf());
+    if (num <= 0 || num >= 4000) return num.toString();
+    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 n = num;
+    for (let i = 0; i < values.length; i++) {
+      while (n >= values[i]) {
+        result += symbols[i];
+        n -= values[i];
+      }
+    }
+    return result;
+  };
+
+  Number.prototype.inRange = function(min: number, max: number): boolean {
+    const num = this.valueOf();
+    return num >= min && num <= max;
+  };
+}

package/src/object-extensions.ts

@@ -0,0 +1,53 @@
+// Object prototype extensions
+export function extendObject() {
+  Object.prototype.isEmpty = function(): boolean {
+    return Object.keys(this).length === 0;
+  };
+
+  Object.prototype.pick = function<T extends Record<string, any>, K extends keyof T>(keys: K[]): Pick<T, K> {
+    const result = {} as Pick<T, K>;
+    const obj = this as T;
+    keys.forEach(key => {
+      if (key in obj) {
+        result[key] = obj[key];
+      }
+    });
+    return result;
+  };
+
+  Object.prototype.omit = function<T extends Record<string, any>, K extends keyof T>(keys: K[]): Omit<T, K> {
+    const result = { ...this } as T;
+    keys.forEach(key => {
+      delete result[key];
+    });
+    return result as Omit<T, K>;
+  };
+
+  Object.prototype.deepClone = function<T>(): T {
+    if (this === null || typeof this !== 'object') return this;
+    if (this instanceof Date) return new Date(this.getTime()) as any;
+    if (this instanceof Array) return this.map(item => item?.deepClone?.() || item) as any;
+    
+    const cloned = {} as T;
+    Object.keys(this).forEach(key => {
+      const value = (this as any)[key];
+      (cloned as any)[key] = value?.deepClone?.() || value;
+    });
+    return cloned;
+  };
+
+  Object.prototype.merge = function(other: Record<string, any>): Record<string, any> {
+    return { ...this, ...other };
+  };
+
+  Object.prototype.deepFreeze = function<T>(): T {
+    const propNames = Object.getOwnPropertyNames(this);
+    for (const name of propNames) {
+      const value = (this as any)[name];
+      if (value && typeof value === 'object') {
+        value.deepFreeze();
+      }
+    }
+    return Object.freeze(this) as T;
+  };
+}

package/src/string-extensions.ts

@@ -0,0 +1,63 @@
+// String prototype extensions
+export function extendString() {
+  String.prototype.toCapitalize = function(): string {
+    return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
+  };
+
+  String.prototype.toCamelCase = function(): string {
+    return this.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : '');
+  };
+
+  String.prototype.toKebabCase = function(): string {
+    return this.replace(/([a-z])([A-Z])/g, '$1-$2')
+               .replace(/[\s_]+/g, '-')
+               .toLowerCase();
+  };
+
+  String.prototype.toSnakeCase = function(): string {
+    return this.replace(/([a-z])([A-Z])/g, '$1_$2')
+               .replace(/[\s-]+/g, '_')
+               .toLowerCase();
+  };
+
+  String.prototype.truncate = function(length: number, suffix: string = '...'): string {
+    return this.length > length ? this.substring(0, length) + suffix : this.toString();
+  };
+
+  String.prototype.isEmail = function(): boolean {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(this.toString());
+  };
+
+  String.prototype.isUrl = function(): boolean {
+    try {
+      new URL(this.toString());
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  String.prototype.removeWhitespace = function(): string {
+    return this.replace(/\s+/g, '');
+  };
+
+  String.prototype.reverse = function(): string {
+    return this.split('').reverse().join('');
+  };
+
+  String.prototype.isPalindrome = function(): boolean {
+    const cleaned = this.toLowerCase().replace(/[^a-z0-9]/g, '');
+    return cleaned === cleaned.split('').reverse().join('');
+  };
+
+  String.prototype.toTitleCase = function(): string {
+    return this.replace(/\w\S*/g, (txt) => 
+      txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()
+    );
+  };
+
+  String.prototype.stripHtml = function(): string {
+    return this.replace(/<[^>]*>/g, '');
+  };
+}

package/src/types.ts

@@ -0,0 +1,56 @@
+// TypeScript declarations for all extensions
+declare global {
+  interface String {
+    toCapitalize(): string;
+    toCamelCase(): string;
+    toKebabCase(): string;
+    toSnakeCase(): string;
+    truncate(length: number, suffix?: string): string;
+    isEmail(): boolean;
+    isUrl(): boolean;
+    removeWhitespace(): string;
+    reverse(): string;
+    isPalindrome(): boolean;
+    toTitleCase(): string;
+    stripHtml(): string;
+  }
+
+  interface Array<T> {
+    unique(): T[];
+    shuffle(): T[];
+    chunk(size: number): T[][];
+    groupBy<K extends string | number>(keyFn: (item: T) => K): Record<K, T[]>;
+    sum(): number;
+    average(): number;
+    compact(): T[];
+    pluck<K extends keyof T>(key: K): T[K][];
+    findLast(predicate: (item: T) => boolean): T | undefined;
+    partition(predicate: (item: T) => boolean): [T[], T[]];
+    flatten(depth?: number): any[];
+    deepFlatten(): any[];
+  }
+
+  interface Object {
+    isEmpty(): boolean;
+    pick<T extends Record<string, any>, K extends keyof T>(keys: K[]): Pick<T, K>;
+    omit<T extends Record<string, any>, K extends keyof T>(keys: K[]): Omit<T, K>;
+    deepClone<T>(): T;
+    merge(other: Record<string, any>): Record<string, any>;
+    deepFreeze<T>(): T;
+  }
+
+  interface Number {
+    toPercent(decimals?: number): string;
+    toCurrency(currency?: string, locale?: string): string;
+    clamp(min: number, max: number): number;
+    isEven(): boolean;
+    isOdd(): boolean;
+    isPrime(): boolean;
+    factorial(): number;
+    toOrdinal(): string;
+    toRoman(): string;
+    inRange(min: number, max: number): boolean;
+  }
+}
+
+export {};

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": ["*", "*.ts", "*.js"]
+    },
+    "lib": ["ES2020", "DOM"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}