@naman_deep_singh/utils 2.1.0

package/README.md

@@ -0,0 +1,218 @@
+@naman_deep_singh/utils
+
+Version: 2.1.0
+
+Universal JavaScript prototype extensions for common development utilities. Works in both Node.js and browser environments with 70+ utility methods.
+
+⚠️ This library extends native prototypes (String, Array, Object, Number). Use consciously in shared or library code.
+
+---
+
+## Installation
+```bash
+npm install @naman_deep_singh/utils
+# or
+pnpm add @naman_deep_singh/utils
+Quick Start
+import { initializeExtensions } from '@naman_deep_singh/utils';
+
+// Initialize all extensions
+initializeExtensions();
+
+// String utilities
+"hello world".toCapitalize();       // "Hello world"
+"hello world".capitalizeWords();    // "Hello World"
+"hello world".reverseWords();       // "world hello"
+"test@email.com".isEmail();         // true
+"hello world".words();              // ["hello", "world"]
+
+// Array utilities
+[1, 2, 2, 3].unique();              // [1, 2, 3]
+[1, 2, 3, 4, 5].chunk(2);           // [[1,2],[3,4],[5]]
+[1, 2, 3].sample();                 // random element
+[1,2,3,4].last();                   // 4
+[{id:1},{id:2},{id:1}].uniqueBy(x => x.id); // [{id:1},{id:2}]
+[3,1,2].sortBy(x => x);             // [1,2,3]
+
+// Number utilities
+(42).toOrdinal();                    // "42nd"
+(0.75).toPercent();                  // "75.00%"
+(3.14159).toFixedNumber(2);          // 3.14
+(5).randomUpTo();                    // 0..5 random number
+(5).times(i => console.log(i));      // 0..4
+
+// Object utilities
+({ a: 1, b: 2 }).pick(['a']);        // { a: 1 }
+({ a: 1, b: 2 }).mapValues(v => v * 2); // { a: 2, b: 4 }
+({ a: 1, b: 2 }).mapKeys(k => k + "_"); // { a_: 1, b_: 2 }
+({}).isEmpty();                       // true
+({ user: { name: "John" } }).getPath('user.name'); // "John"
+({ a: 1, b: 2 }).filterKeys(k => k === 'a'); // { a: 1 }
+({ a: 1, b: 2 }).filterValues(v => v === 1); // { a: 1 }
+Error Handling & Validation
+All methods include strict runtime validation and throw clear native errors.
+
+"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 as any);
+// TypeError: pick: keys must be an array, got object
+
+(3.14).round(-1);
+// TypeError: round: decimals must be a non-negative integer, got -1
+Error Types Used
+
+TypeError – invalid type or missing argument
+
+RangeError – out-of-range numeric values (e.g. toRoman)
+
+✅ No custom error classes are exposed — only standard JS errors.
+
+Configuration
+Selective Extension Loading
+import { initializeExtensions, extend } from '@naman_deep_singh/utils';
+
+// Enable only specific prototypes
+initializeExtensions({
+  string: true,
+  array: true,
+  object: false,
+  number: false,
+});
+
+// Or initialize individually
+extend.string();
+extend.array();
+Performance Configuration
+Caching System
+import { setPerformanceConfig } from '@naman_deep_singh/utils';
+
+setPerformanceConfig({
+  enableCaching: true,
+  maxCacheSize: 200,
+});
+Notes:
+
+Validation cannot be disabled
+
+Caching is optional
+
+Uses a simple LRU cache
+
+String Extensions (21 methods)
+Case Conversion
+
+"hello world".toCapitalize();    // "Hello world"
+"hello world".capitalizeWords(); // "Hello World"
+"hello-world".toCamelCase();     // "helloWorld"
+"HelloWorld".toKebabCase();      // "hello-world"
+"Hello World".toSnakeCase();     // "hello_world"
+"hello world".toTitleCase();     // "Hello World"
+Validation & Checks
+
+"test@example.com".isEmail();   // true
+"https://example.com".isUrl();  // true
+"racecar".isPalindrome();       // true
+Text Utilities
+
+"Long text here".truncate(8);        // "Long tex..."
+"hello world".truncateWords(1);      // "hello..."
+"hello world".removeWhitespace();    // "helloworld"
+"<p>Hello</p>".stripHtml();          // "Hello"
+"hello".reverse();                   // "olleh"
+"hello world".reverseWords();        // "world hello"
+"hello hello".count("hello");        // 2
+"Hello World".slugify();             // "hello-world"
+"hello world".words();               // ["hello", "world"]
+"hello\nworld".lines();              // ["hello","world"]
+Array Extensions (23 methods)
+Core Utilities
+
+[1, 2, 2, 3].unique();                  // [1,2,3]
+[{id:1},{id:2},{id:1}].uniqueBy(x => x.id); // [{id:1},{id:2}]
+[1,2,3,4,5].shuffle();                  // random order
+[1,2,3,4,5].chunk(2);                   // [[1,2],[3,4],[5]]
+[0,1,false,2,"",3].compact();           // [1,2,3] removes null, undefined, false, and empty strings
+[1,2,3,4].last();                        // 4
+[3,1,2].sortBy(x => x);                  // [1,2,3]
+Math
+
+[1,2,3].sum();       // 6
+[1,2,3].average();   // 2
+Advanced
+
+users.groupBy(u => u.age);
+users.pluck('name');
+[1,2,3,4].partition(n => n % 2 === 0);
+// [[2,4],[1,3]]
+Set Operations
+
+[1,2,3].difference([2]);     // [1,3]
+[1,2,3].intersection([2,3]); // [2,3]
+[1,2,3].union([3,4]);        // [1,2,3,4]
+Object Extensions (13 methods)
+({}).isEmpty(); // true
+({ a: 1, b: 2 }).pick(['a']);      // { a: 1 }
+({ a: 1, b: 2 }).omit(['b']);      // { a: 1 }
+({ a: 1, b: 2 }).mapValues(v => v*2); // { a: 2, b: 4 }
+({ a: 1, b: 2 }).mapKeys(k => k+"_");  // { a_:1, b_:2 }
+({ a: 1, b: 2 }).filterKeys(k => k==='a'); // { a:1 }
+({ a: 1, b: 2 }).filterValues(v => v===1); // { a:1 }
+({ a: { b: 2 } }).deepClone();
+({ a: { b: 2 } }).deepFreeze();
+data.hasPath('user.profile.name');
+data.getPath('user.profile.email', 'N/A');
+data.setPath('user.profile.email', 'john@example.com');
+Number Extensions (19 methods)
+(0.75).toPercent();                 // "75.00%"
+(3.14159).toFixedNumber(2);         // 3.14
+(1234.56).toCurrency();             // "$1,234.56"
+(1234.56).toCurrency('EUR','de-DE'); // "1.234,56 €"
+(5).clamp(1,10);                     // 5
+(5).inRange(1,10);                   // true
+(7).isPrime();                        // true
+(5).factorial();                      // 120
+(5).randomUpTo();                     // 0..5
+(3).times(i => console.log(i));      // 0,1,2
+(42).toOrdinal();                     // "42nd"
+(123).sign();                         // 1
+Caching Details
+Cached Methods (when enabled):
+
+Number.isPrime()
+
+Number.factorial()
+
+Number.toRoman()
+
+Custom Caching:
+
+import { withCache } from '@naman_deep_singh/utils';
+const result = withCache('key', () => expensiveFn());
+TypeScript Support
+Full global augmentation
+
+Strict typing for all methods
+
+Zero any leakage in public APIs
+
+const x: number[] = [1,2,2].unique();
+const y: string = "hello".toCapitalize();
+Package Stats
+~70 utility methods
+
+Zero dependencies
+
+Node.js + Browser
+
+TypeScript-first
+
+Optional LRU caching
+
+Strict runtime validation

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

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

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendArray = extendArray;
+const utils_1 = require("src/utils");
+let arrayExtended = false;
+function extendArray() {
+    if (arrayExtended)
+        return;
+    arrayExtended = true;
+    (0, utils_1.defineExtension)(Array.prototype, 'unique', function () {
+        return [...new Set(this)];
+    });
+    (0, utils_1.defineExtension)(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;
+    });
+    (0, utils_1.defineExtension)(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));
+        }
+        return chunks;
+    });
+    (0, utils_1.defineExtension)(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])
+                groups[key] = [];
+            groups[key].push(item);
+            return groups;
+        }, {});
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'sum', function () {
+        if (this.length === 0) {
+            throw new TypeError('sum: array must contain at least one number');
+        }
+        return this.reduce((sum, num) => sum + num, 0);
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'average', function () {
+        if (this.length === 0) {
+            throw new TypeError('average: array must contain at least one number');
+        }
+        return this.reduce((sum, num) => sum + num, 0) / this.length;
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'compact', function () {
+        return this.filter((item) => item !== null && item !== undefined && item !== '');
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'compactTruthy', function () {
+        return this.filter(Boolean);
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'pluck', function (key) {
+        return this.map((item) => item[key]).filter((val) => val !== undefined);
+    });
+    (0, utils_1.defineExtension)(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];
+        }
+        return undefined;
+    });
+    (0, utils_1.defineExtension)(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));
+        return [truthy, falsy];
+    });
+    (0, utils_1.defineExtension)(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();
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'deepFlatten', function () {
+        return this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.deepFlatten() : val), []);
+    });
+    (0, utils_1.defineExtension)(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));
+    });
+    (0, utils_1.defineExtension)(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));
+    });
+    (0, utils_1.defineExtension)(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])];
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'sample', function () {
+        return this.length > 0
+            ? this[Math.floor(Math.random() * this.length)]
+            : undefined;
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'take', function (count) {
+        return this.slice(0, Math.max(0, count));
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'drop', function (count) {
+        return this.slice(Math.max(0, count));
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'uniqueBy', function (keyFn) {
+        if (typeof keyFn !== 'function') {
+            throw new TypeError(`uniqueBy: keyFn must be a function, got ${typeof keyFn}`);
+        }
+        const seen = new Set();
+        const result = [];
+        for (const item of this) {
+            const key = keyFn(item);
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(item);
+            }
+        }
+        return result;
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'sortBy', function (keyFn) {
+        if (typeof keyFn !== 'function') {
+            throw new TypeError(`sortBy: keyFn must be a function, got ${typeof keyFn}`);
+        }
+        return [...this].sort((a, b) => {
+            const aVal = keyFn(a);
+            const bVal = keyFn(b);
+            if (aVal < bVal)
+                return -1;
+            if (aVal > bVal)
+                return 1;
+            return 0;
+        });
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'last', function () {
+        return this.length > 0 ? this[this.length - 1] : undefined;
+    });
+}

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/core/performance.d.ts

@@ -0,0 +1,17 @@
+export interface PerformanceConfig {
+    enableCaching?: boolean;
+    maxCacheSize?: number;
+    enableValidation?: boolean;
+}
+export declare function setPerformanceConfig(newConfig: Partial<PerformanceConfig>): void;
+export declare function getPerformanceConfig(): PerformanceConfig;
+export declare class LRUCache<K, V> {
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    clear(): void;
+}
+export declare function makeInternalCacheKey(domain: string, key: string | number): string;
+export declare function withCache<T>(key: string, fn: () => T): T;

package/dist/cjs/core/performance.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUCache = void 0;
+exports.setPerformanceConfig = setPerformanceConfig;
+exports.getPerformanceConfig = getPerformanceConfig;
+exports.makeInternalCacheKey = makeInternalCacheKey;
+exports.withCache = withCache;
+const version_1 = require("./version");
+const defaultConfig = {
+    enableCaching: false,
+    maxCacheSize: 100,
+    enableValidation: true,
+};
+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 };
+}
+// Simple LRU cache for expensive operations
+class LRUCache {
+    constructor(maxSize = 100) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            // Move to end (most recently used)
+            this.cache.delete(key);
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.maxSize) {
+            // Remove least recently used (first item)
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+exports.LRUCache = LRUCache;
+let cache = null;
+function getOrCreateCache() {
+    if (!cache) {
+        cache = new LRUCache(config.maxCacheSize);
+    }
+    return cache;
+}
+function makeInternalCacheKey(domain, key) {
+    const INTERNAL_CACHE_PREFIX = '@js-ext' + (0, version_1.getPackageVersion)();
+    return `${INTERNAL_CACHE_PREFIX}:${domain}:${key}`;
+}
+function withCache(key, fn) {
+    if (!config.enableCaching) {
+        return fn();
+    }
+    const currentCache = getOrCreateCache();
+    const cached = currentCache.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = fn();
+    currentCache.set(key, result);
+    return result;
+}

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

@@ -0,0 +1,4 @@
+export declare function validateExtensionInput(value: any, type: string, methodName: string): void;
+export declare function validateArrayInput<T>(arr: T[], methodName: string): void;
+export declare function validateNumberRange(num: number, min: number, max: number, methodName: string): void;
+export declare function validatePositiveInteger(num: number, methodName: string): void;

package/dist/cjs/core/validation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExtensionInput = validateExtensionInput;
+exports.validateArrayInput = validateArrayInput;
+exports.validateNumberRange = validateNumberRange;
+exports.validatePositiveInteger = validatePositiveInteger;
+// Validation utilities for extensions
+function validateExtensionInput(value, type, methodName) {
+    if (value == null) {
+        throw new TypeError(`Cannot call ${methodName} on ${value}`);
+    }
+    const actualType = typeof value;
+    if (actualType !== type) {
+        throw new TypeError(`${methodName} can only be called on ${type} values, got ${actualType}`);
+    }
+}
+function validateArrayInput(arr, methodName) {
+    if (!Array.isArray(arr)) {
+        throw new TypeError(`${methodName} can only be called on arrays`);
+    }
+}
+function validateNumberRange(num, min, max, methodName) {
+    if (num < min || num > max) {
+        throw new RangeError(`${methodName}: number must be between ${min} and ${max}, got ${num}`);
+    }
+}
+function validatePositiveInteger(num, methodName) {
+    if (!Number.isInteger(num) || num < 0) {
+        throw new TypeError(`${methodName}: expected positive integer, got ${num}`);
+    }
+}

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

@@ -0,0 +1 @@
+export declare const getPackageVersion: () => string;

package/dist/cjs/core/version.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = void 0;
+const node_module_1 = require("node:module");
+const requireFn = (0, node_module_1.createRequire)('../../package.json');
+const getPackageVersion = () => {
+    return requireFn('../package.json').version;
+};
+exports.getPackageVersion = getPackageVersion;

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

@@ -0,0 +1,61 @@
+import '../types/global-augmentations';
+import { extendArray } from './array';
+import { extendNumber } from './number';
+import { extendObject } from './object';
+import { extendString } from './string';
+import { LRUCache, getPerformanceConfig, setPerformanceConfig, withCache } from './core/performance';
+import { validateArrayInput, validateExtensionInput, validateNumberRange, validatePositiveInteger } from './core/validation';
+import { mergeConfigs, validateConfig, validatePerformanceSettings } from './utils/config';
+import { ensurePositiveInteger, getPathSegments, hasOwnProperty, isValidArrayIndex, safeClone } from './utils/helpers';
+import { ExtensionOptions, PerformanceConfig } from './types/extension-types';
+export { ExtensionOptions, PerformanceConfig };
+export { withCache };
+import { extendAll } from './init/initializer';
+/**
+ * Initialize JavaScript prototype extensions
+ * @param options - Configure which extensions to enable (default: all enabled)
+ */
+export declare function initializeExtensions(options?: ExtensionOptions): void;
+/**
+ * Initialize all extensions (convenience function)
+ */
+export { extendAll };
+/**
+ * Selective prototype extension helpers
+ * Initialize only specific extensions
+ */
+export declare const extend: {
+    string: typeof extendString;
+    array: typeof extendArray;
+    object: typeof extendObject;
+    number: typeof extendNumber;
+};
+export { validateExtensionInput, validateArrayInput, validateNumberRange, validatePositiveInteger, };
+export { validateConfig, validatePerformanceSettings, mergeConfigs, isValidArrayIndex, ensurePositiveInteger, safeClone, getPathSegments, hasOwnProperty, };
+export { LRUCache, setPerformanceConfig, getPerformanceConfig };
+declare const _default: {
+    initializeExtensions: typeof initializeExtensions;
+    extendAll: typeof extendAll;
+    extend: {
+        string: typeof extendString;
+        array: typeof extendArray;
+        object: typeof extendObject;
+        number: typeof extendNumber;
+    };
+    LRUCache: typeof LRUCache;
+    setPerformanceConfig: typeof setPerformanceConfig;
+    getPerformanceConfig: typeof getPerformanceConfig;
+    validateExtensionInput: typeof validateExtensionInput;
+    validateArrayInput: typeof validateArrayInput;
+    validateNumberRange: typeof validateNumberRange;
+    validatePositiveInteger: typeof validatePositiveInteger;
+    validateConfig: typeof validateConfig;
+    validatePerformanceSettings: typeof validatePerformanceSettings;
+    mergeConfigs: typeof mergeConfigs;
+    isValidArrayIndex: typeof isValidArrayIndex;
+    ensurePositiveInteger: typeof ensurePositiveInteger;
+    safeClone: typeof safeClone;
+    getPathSegments: typeof getPathSegments;
+    hasOwnProperty: typeof hasOwnProperty;
+};
+export default _default;