@naman_deep_singh/js-extensions 1.2.0 → 1.3.1

package/README.md

@@ -1,6 +1,7 @@
+
 # @naman_deep_singh/js-extensions
 
-**Version:** 1.2.0
+**Version:** 1.3.1
 
 Universal JavaScript prototype extensions for common development utilities. Works in both Node.js and browser environments with 50+ utility methods.
 
@@ -15,10 +16,11 @@ pnpm add @naman_deep_singh/js-extensions
 ## Quick Start
 
 ```typescript
-import { initExtensions } from '@naman_deep_singh/js-extensions';
+
+import { initializeExtensions } from '@naman_deep_singh/js-extensions';
 
 // Initialize all extensions
-initExtensions();
+initializeExtensions();
 
 // String utilities
 "hello world".toCapitalize(); // "Hello world"
@@ -41,15 +43,49 @@ initExtensions();
 ({user: {name: "John"}}).getPath('user.name'); // "John"
 ```
 
+
+## Error Handling & Validation
+
+All methods now include comprehensive input validation to ensure reliability and prevent runtime errors.
+
+### Input Validation
+```typescript
+// Invalid inputs now throw clear TypeError messages
+"hello".count(123); // TypeError: count: substring must be a string, got number
+"hello".count("");  // TypeError: count: substring cannot be empty
+[].sum();           // TypeError: sum: array must contain at least one number
+({a: 1}).pick(null); // TypeError: pick: keys must be an array, got object
+(3.14).round(-1);    // TypeError: round: decimals must be a non-negative integer, got -1
+```
+
+### Consistent Error Types
+- **`TypeError`** - Invalid parameter types or missing required values
+- **`RangeError`** - Out-of-range values (e.g., `toRoman` number limits)
+
+### Performance vs Validation Trade-off
+```typescript
+import { setPerformanceConfig } from '@naman_deep_singh/js-extensions';
+
+// Validation is enabled by default for reliability
+setPerformanceConfig({
+  enableCaching: true,    // Cache expensive operations
+  enableValidation: true  // Input validation enabled (default)
+});
+
+// Note: Currently validation cannot be disabled as it's built into the methods
+// Future versions may add an option to disable validation for maximum performance
+```
+
 ## Configuration
 
 ### Selective Extensions
 
 ```typescript
-import { initExtensions, extend } from '@naman_deep_singh/js-extensions';
+
+import { initializeExtensions, extend } from '@naman_deep_singh/js-extensions';
 
 // Only specific types
-initExtensions({ 
+initializeExtensions({
   string: true, 
   array: true, 
   object: false, 
@@ -64,10 +100,11 @@ extend.array();  // Only array methods
 ### Performance Configuration
 
 ```typescript
-import { initExtensions, setPerformanceConfig } from '@naman_deep_singh/js-extensions';
+
+import { initializeExtensions, setPerformanceConfig } from '@naman_deep_singh/js-extensions';
 
 // Configure performance options
-initExtensions({
+initializeExtensions({
   performance: {
     enableCaching: true,    // Cache expensive operations
     maxCacheSize: 200,      // LRU cache size
@@ -336,6 +373,7 @@ const config: PerformanceConfig = {
 };
 ```
 
+
 ## Package Stats
 
 - **60 utility methods** across 4 JavaScript types
@@ -343,13 +381,15 @@ const config: PerformanceConfig = {
 - **Universal compatibility** - Node.js and browser
 - **TypeScript native** - complete type definitions
 - **Performance optimized** - optional caching system
+- **Production-ready** - comprehensive input validation
 - **Tree-shakable** - selective imports supported
 
 ## Complete API Reference
 
 ### Core Functions
 ```typescript
-initExtensions(options?: ExtensionOptions): void
+
+initializeExtensions(options?: ExtensionOptions): void
 extendAll(): void
 setPerformanceConfig(config: Partial<PerformanceConfig>): void
 getPerformanceConfig(): PerformanceConfig

package/dist/cjs/{array-extensions.js → array/array-extensions.js}

@@ -15,6 +15,9 @@ function extendArray() {
         return arr;
     };
     Array.prototype.chunk = function (size) {
+        if (!Number.isInteger(size) || size <= 0) {
+            throw new TypeError(`chunk: size must be a positive integer, got ${size}`);
+        }
         const chunks = [];
         for (let i = 0; i < this.length; i += size) {
             chunks.push(this.slice(i, i + size));
@@ -22,6 +25,9 @@ function extendArray() {
         return chunks;
     };
     Array.prototype.groupBy = function (keyFn) {
+        if (typeof keyFn !== 'function') {
+            throw new TypeError(`groupBy: keyFn must be a function, got ${typeof keyFn}`);
+        }
         return this.reduce((groups, item) => {
             const key = keyFn(item);
             if (!groups[key])
@@ -31,19 +37,32 @@ function extendArray() {
         }, {});
     };
     Array.prototype.sum = function () {
-        return this.reduce((sum, num) => sum + (typeof num === 'number' ? num : 0), 0);
+        const numbers = this.filter(item => typeof item === 'number');
+        if (numbers.length === 0) {
+            throw new TypeError('sum: array must contain at least one number');
+        }
+        return numbers.reduce((sum, num) => sum + num, 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;
+        if (numbers.length === 0) {
+            throw new TypeError('average: array must contain at least one number');
+        }
+        return numbers.reduce((sum, num) => sum + num, 0) / numbers.length;
     };
     Array.prototype.compact = function () {
         return this.filter(item => item != null && item !== '' && item !== false);
     };
     Array.prototype.pluck = function (key) {
+        if (typeof key !== 'string' && typeof key !== 'number' && typeof key !== 'symbol') {
+            throw new TypeError(`pluck: key must be a string, number, or symbol, got ${typeof key}`);
+        }
         return this.map(item => item && typeof item === 'object' ? item[key] : undefined).filter(val => val !== undefined);
     };
     Array.prototype.findLast = function (predicate) {
+        if (typeof predicate !== 'function') {
+            throw new TypeError(`findLast: predicate must be a function, got ${typeof predicate}`);
+        }
         for (let i = this.length - 1; i >= 0; i--) {
             if (predicate(this[i]))
                 return this[i];
@@ -51,6 +70,9 @@ function extendArray() {
         return undefined;
     };
     Array.prototype.partition = function (predicate) {
+        if (typeof predicate !== 'function') {
+            throw new TypeError(`partition: predicate must be a function, got ${typeof predicate}`);
+        }
         const truthy = [];
         const falsy = [];
         this.forEach(item => predicate(item) ? truthy.push(item) : falsy.push(item));
@@ -63,12 +85,21 @@ function extendArray() {
         return this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.deepFlatten() : val), []);
     };
     Array.prototype.difference = function (other) {
+        if (!Array.isArray(other)) {
+            throw new TypeError(`difference: other must be an array, got ${typeof other}`);
+        }
         return this.filter(item => !other.includes(item));
     };
     Array.prototype.intersection = function (other) {
+        if (!Array.isArray(other)) {
+            throw new TypeError(`intersection: other must be an array, got ${typeof other}`);
+        }
         return this.filter(item => other.includes(item));
     };
     Array.prototype.union = function (other) {
+        if (!Array.isArray(other)) {
+            throw new TypeError(`union: other must be an array, got ${typeof other}`);
+        }
         return [...new Set([...this, ...other])];
     };
     Array.prototype.sample = function () {

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

@@ -0,0 +1 @@
+export { extendArray } from './array-extensions';

package/dist/cjs/array/index.js

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

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

@@ -0,0 +1,2 @@
+export * from './validation';
+export * from './performance';

package/dist/cjs/core/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 core utilities
+__exportStar(require("./validation"), exports);
+__exportStar(require("./performance"), exports);

package/dist/cjs/{performance.d.ts → core/performance.d.ts}

@@ -5,7 +5,7 @@ export interface PerformanceConfig {
 }
 export declare function setPerformanceConfig(newConfig: Partial<PerformanceConfig>): void;
 export declare function getPerformanceConfig(): PerformanceConfig;
-declare class LRUCache<K, V> {
+export declare class LRUCache<K, V> {
     private cache;
     private maxSize;
     constructor(maxSize?: number);
@@ -13,6 +13,4 @@ declare class LRUCache<K, V> {
     set(key: K, value: V): void;
     clear(): void;
 }
-export declare const cache: LRUCache<unknown, unknown>;
 export declare function withCache<T>(key: string, fn: () => T): T;
-export {};

package/dist/cjs/{performance.js → core/performance.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cache = void 0;
+exports.LRUCache = void 0;
 exports.setPerformanceConfig = setPerformanceConfig;
 exports.getPerformanceConfig = getPerformanceConfig;
 exports.withCache = withCache;
@@ -11,7 +11,12 @@ const defaultConfig = {
 };
 let config = { ...defaultConfig };
 function setPerformanceConfig(newConfig) {
+    const oldMaxSize = config.maxCacheSize;
     config = { ...config, ...newConfig };
+    // Recreate cache if maxCacheSize changed
+    if (cache && oldMaxSize !== config.maxCacheSize) {
+        cache = new LRUCache(config.maxCacheSize);
+    }
 }
 function getPerformanceConfig() {
     return { ...config };
@@ -48,16 +53,24 @@ class LRUCache {
         this.cache.clear();
     }
 }
-exports.cache = new LRUCache(config.maxCacheSize);
+exports.LRUCache = LRUCache;
+let cache = null;
+function getOrCreateCache() {
+    if (!cache) {
+        cache = new LRUCache(config.maxCacheSize);
+    }
+    return cache;
+}
 function withCache(key, fn) {
     if (!config.enableCaching) {
         return fn();
     }
-    const cached = exports.cache.get(key);
+    const currentCache = getOrCreateCache();
+    const cached = currentCache.get(key);
     if (cached !== undefined) {
         return cached;
     }
     const result = fn();
-    exports.cache.set(key, result);
+    currentCache.set(key, result);
     return result;
 }

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

@@ -0,0 +1,4 @@
+export * from '../string';
+export * from '../array';
+export * from '../object';
+export * from '../number';

package/dist/cjs/extensions/index.js

@@ -0,0 +1,21 @@
+"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 all extensions
+__exportStar(require("../string"), exports);
+__exportStar(require("../array"), exports);
+__exportStar(require("../object"), exports);
+__exportStar(require("../number"), exports);

package/dist/cjs/index.d.ts

@@ -1,26 +1,22 @@
-import { extendString } from './string-extensions';
-import { extendArray } from './array-extensions';
-import { extendObject } from './object-extensions';
-import { extendNumber } from './number-extensions';
-import { setPerformanceConfig, getPerformanceConfig, type PerformanceConfig, withCache } from './performance';
-import './types';
+import '../types/global-augmentations';
+import { extendString } from './string';
+import { extendArray } from './array';
+import { extendObject } from './object';
+import { extendNumber } from './number';
+import { withCache, setPerformanceConfig, getPerformanceConfig } from './core/performance';
+import { ExtensionOptions, PerformanceConfig } from './types/extension-types';
+export { ExtensionOptions, PerformanceConfig };
 export { withCache };
-export interface ExtensionOptions {
-    string?: boolean;
-    array?: boolean;
-    object?: boolean;
-    number?: boolean;
-    performance?: PerformanceConfig;
-}
+import { extendAll } from './init/initializer';
 /**
  * Initialize JavaScript prototype extensions
  * @param options - Configure which extensions to enable (default: all enabled)
  */
-export declare function initExtensions(options?: ExtensionOptions): void;
+export declare function initializeExtensions(options?: ExtensionOptions): void;
 /**
  * Initialize all extensions (convenience function)
  */
-export declare function extendAll(): void;
+export { extendAll };
 /**
  * Initialize only specific extensions
  */
@@ -30,9 +26,9 @@ export declare const extend: {
     object: typeof extendObject;
     number: typeof extendNumber;
 };
-export { setPerformanceConfig, getPerformanceConfig, type PerformanceConfig };
+export { setPerformanceConfig, getPerformanceConfig };
 declare const _default: {
-    initExtensions: typeof initExtensions;
+    initializeExtensions: typeof initializeExtensions;
     extendAll: typeof extendAll;
     extend: {
         string: typeof extendString;

package/dist/cjs/index.js

@@ -1,53 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPerformanceConfig = exports.setPerformanceConfig = exports.extend = exports.withCache = 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");
-const performance_1 = require("./performance");
+exports.getPerformanceConfig = exports.setPerformanceConfig = exports.extend = exports.extendAll = exports.withCache = void 0;
+exports.initializeExtensions = initializeExtensions;
+// Import types first
+require("../types/global-augmentations");
+// Import extension modules
+const string_1 = require("./string");
+const array_1 = require("./array");
+const object_1 = require("./object");
+const number_1 = require("./number");
+// Import core utilities
+const performance_1 = require("./core/performance");
+Object.defineProperty(exports, "withCache", { enumerable: true, get: function () { return performance_1.withCache; } });
 Object.defineProperty(exports, "setPerformanceConfig", { enumerable: true, get: function () { return performance_1.setPerformanceConfig; } });
 Object.defineProperty(exports, "getPerformanceConfig", { enumerable: true, get: function () { return performance_1.getPerformanceConfig; } });
-Object.defineProperty(exports, "withCache", { enumerable: true, get: function () { return performance_1.withCache; } });
-require("./types");
+// 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 initExtensions(options = {}) {
-    const { string = true, array = true, object = true, number = true, performance } = options;
-    if (performance) {
-        (0, performance_1.setPerformanceConfig)(performance);
-    }
-    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();
+function initializeExtensions(options = {}) {
+    (0, initializer_1.initExtensions)(options);
 }
 /**
  * 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
+    string: string_1.extendString,
+    array: array_1.extendArray,
+    object: object_1.extendObject,
+    number: number_1.extendNumber
 };
+// Default export
 exports.default = {
-    initExtensions,
-    extendAll,
+    initializeExtensions,
+    extendAll: initializer_1.extendAll,
     extend: exports.extend,
     setPerformanceConfig: performance_1.setPerformanceConfig,
     getPerformanceConfig: performance_1.getPerformanceConfig

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 { 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,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initExtensions = initExtensions;
+exports.extendAll = extendAll;
+const string_1 = require("../string");
+const array_1 = require("../array");
+const object_1 = require("../object");
+const number_1 = require("../number");
+const performance_1 = require("../core/performance");
+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 { 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-extensions.js → number/number-extensions.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extendNumber = extendNumber;
 // Number prototype extensions
-const performance_1 = require("./performance");
+const performance_1 = require("../core/performance");
 function extendNumber() {
     Number.prototype.toPercent = function (decimals = 2) {
         return (this.valueOf() * 100).toFixed(decimals) + '%';
@@ -14,6 +14,9 @@ function extendNumber() {
         }).format(this.valueOf());
     };
     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.valueOf(), min), max);
     };
     Number.prototype.isEven = function () {
@@ -56,9 +59,14 @@ function extendNumber() {
     };
     Number.prototype.toRoman = function () {
         const num = Math.floor(this.valueOf());
+        // Better validation for roman numerals
+        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)(`roman_${num}`, () => {
-            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 = '';
@@ -77,14 +85,23 @@ function extendNumber() {
         return num >= min && num <= max;
     };
     Number.prototype.round = function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0) {
+            throw new TypeError(`round: decimals must be a non-negative integer, got ${decimals}`);
+        }
         const factor = Math.pow(10, decimals);
         return Math.round(this.valueOf() * factor) / factor;
     };
     Number.prototype.ceil = function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0) {
+            throw new TypeError(`ceil: decimals must be a non-negative integer, got ${decimals}`);
+        }
         const factor = Math.pow(10, decimals);
         return Math.ceil(this.valueOf() * factor) / factor;
     };
     Number.prototype.floor = function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0) {
+            throw new TypeError(`floor: decimals must be a non-negative integer, got ${decimals}`);
+        }
         const factor = Math.pow(10, decimals);
         return Math.floor(this.valueOf() * factor) / factor;
     };
@@ -95,6 +112,9 @@ function extendNumber() {
         return Math.sign(this.valueOf());
     };
     Number.prototype.times = function (callback) {
+        if (typeof callback !== 'function') {
+            throw new TypeError(`times: callback must be a function, got ${typeof callback}`);
+        }
         const num = Math.floor(this.valueOf());
         for (let i = 0; i < num; i++) {
             callback(i);

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; } });