@catbee/utils 1.0.5 → 2.0.0-next.0

package/obj/index.mjs

@@ -0,0 +1,301 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/obj/obj.utils.ts
+function isObjEmpty(obj) {
+  return !!obj && typeof obj === "object" && Object.keys(obj).length === 0;
+}
+__name(isObjEmpty, "isObjEmpty");
+function pick(obj, keys) {
+  return Object.fromEntries(keys.map((key) => [
+    key,
+    obj[key]
+  ]));
+}
+__name(pick, "pick");
+function omit(obj, keys) {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));
+}
+__name(omit, "omit");
+function deepObjMerge(target, ...sources) {
+  if (!sources.length) return target;
+  const seen = /* @__PURE__ */ new WeakMap();
+  seen.set(target, target);
+  for (const s of sources) {
+    if (s && typeof s === "object") {
+      seen.set(s, target);
+    }
+  }
+  function deepClone2(value) {
+    if (value === null || typeof value !== "object") return value;
+    if (seen.has(value)) return seen.get(value);
+    if (value instanceof Date) {
+      return new Date(value.getTime());
+    }
+    if (Array.isArray(value)) {
+      const clone2 = [];
+      seen.set(value, clone2);
+      value.forEach((item, i) => clone2[i] = deepClone2(item));
+      return clone2;
+    }
+    if (value instanceof Set) {
+      const clone2 = /* @__PURE__ */ new Set();
+      seen.set(value, clone2);
+      value.forEach((item) => clone2.add(deepClone2(item)));
+      return clone2;
+    }
+    if (value instanceof Map) {
+      const clone2 = /* @__PURE__ */ new Map();
+      seen.set(value, clone2);
+      value.forEach((val, key) => clone2.set(key, deepClone2(val)));
+      return clone2;
+    }
+    if (value instanceof RegExp) {
+      return new RegExp(value.source, value.flags);
+    }
+    if (value instanceof ArrayBuffer) {
+      return value.slice(0);
+    }
+    if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+      const typed = value;
+      const ctor = typed.constructor;
+      const typedArrayCtors = [
+        Int8Array,
+        Uint8Array,
+        Uint8ClampedArray,
+        Int16Array,
+        Uint16Array,
+        Int32Array,
+        Uint32Array,
+        Float32Array,
+        Float64Array,
+        BigInt64Array,
+        BigUint64Array
+      ].filter(Boolean);
+      const typedArrayCtorSet = new Set(typedArrayCtors);
+      if (typeof ctor === "function" && typedArrayCtorSet.has(ctor)) {
+        const buffer = typed.buffer && typeof typed.buffer.slice === "function" ? typed.buffer.slice(0) : typed.buffer;
+        const clone2 = new ctor(buffer, typed.byteOffset, typed.length);
+        seen.set(value, clone2);
+        return clone2;
+      } else if (typeof typed.slice === "function") {
+        const clone2 = typed.slice();
+        seen.set(value, clone2);
+        return clone2;
+      } else {
+        throw new Error("Cannot deep clone unknown TypedArray type: " + (typed && typed.constructor && typed.constructor.name));
+      }
+    }
+    const clone = Object.create(Object.getPrototypeOf(value));
+    seen.set(value, clone);
+    Reflect.ownKeys(value).forEach((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor.get || descriptor.set) {
+        Object.defineProperty(clone, key, descriptor);
+      } else {
+        clone[key] = deepClone2(value[key]);
+      }
+    });
+    return clone;
+  }
+  __name(deepClone2, "deepClone");
+  function mergeProp(target2, source, key) {
+    const targetValue = target2[key];
+    const sourceValue = source[key];
+    if (sourceValue === void 0) return;
+    if (sourceValue === null || typeof sourceValue !== "object") {
+      target2[key] = sourceValue;
+      return;
+    }
+    if (Array.isArray(sourceValue)) {
+      target2[key] = deepClone2(sourceValue);
+      return;
+    }
+    if (sourceValue instanceof Date || sourceValue instanceof RegExp || sourceValue instanceof Set || sourceValue instanceof Map || sourceValue instanceof ArrayBuffer || ArrayBuffer.isView(sourceValue) && !(sourceValue instanceof DataView)) {
+      target2[key] = deepClone2(sourceValue);
+      return;
+    }
+    if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+      for (const k of Reflect.ownKeys(sourceValue)) {
+        mergeProp(targetValue, sourceValue, k);
+      }
+      return;
+    }
+    target2[key] = deepClone2(sourceValue);
+  }
+  __name(mergeProp, "mergeProp");
+  for (const source of sources) {
+    if (source == null) continue;
+    for (const key of Reflect.ownKeys(source)) {
+      mergeProp(target, source, key);
+    }
+  }
+  return target;
+}
+__name(deepObjMerge, "deepObjMerge");
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+__name(isPlainObject, "isPlainObject");
+function flattenObject(obj, prefix = "") {
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      Object.assign(acc, flattenObject(value, newKey));
+    } else {
+      acc[newKey] = value;
+    }
+    return acc;
+  }, {});
+}
+__name(flattenObject, "flattenObject");
+function getValueByPath(obj, path) {
+  if (!obj || typeof obj !== "object") return void 0;
+  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  return parts.reduce((acc, key) => acc?.[key], obj);
+}
+__name(getValueByPath, "getValueByPath");
+function setValueByPath(obj, path, value) {
+  if (!obj || typeof obj !== "object") return obj;
+  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  if (parts.length === 0) return obj;
+  const forbiddenKeys = /* @__PURE__ */ new Set([
+    "__proto__",
+    "prototype",
+    "constructor"
+  ]);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (forbiddenKeys.has(key)) {
+      return obj;
+    }
+    const nextKey = parts[i + 1];
+    const isArrayIndex = !isNaN(Number(nextKey));
+    if (current[key] === void 0) {
+      current[key] = isArrayIndex ? [] : /* @__PURE__ */ Object.create(null);
+    } else if (typeof current[key] !== "object" || current[key] === null) {
+      current[key] = isArrayIndex ? [] : /* @__PURE__ */ Object.create(null);
+    }
+    current = current[key];
+  }
+  const finalKey = parts[parts.length - 1];
+  if (forbiddenKeys.has(finalKey)) {
+    return obj;
+  }
+  current[finalKey] = value;
+  return obj;
+}
+__name(setValueByPath, "setValueByPath");
+function isEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof Date || b instanceof Date) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!isEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every((key) => Object.prototype.hasOwnProperty.call(b, key) && isEqual(a[key], b[key]));
+}
+__name(isEqual, "isEqual");
+function filterObject(obj, predicate) {
+  return Object.fromEntries(Object.entries(obj).filter(([key, value]) => predicate(value, key, obj)));
+}
+__name(filterObject, "filterObject");
+function mapObject(obj, mapFn) {
+  return Object.fromEntries(Object.entries(obj).map(([key, value]) => [
+    key,
+    mapFn(value, key, obj)
+  ]));
+}
+__name(mapObject, "mapObject");
+function deepClone(value) {
+  try {
+    if (typeof globalThis.structuredClone === "function") {
+      return globalThis.structuredClone(value);
+    }
+  } catch (_) {
+  }
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch (_) {
+    return value;
+  }
+}
+__name(deepClone, "deepClone");
+function deepFreeze(obj) {
+  Object.freeze(obj);
+  for (const prop of Object.getOwnPropertyNames(obj)) {
+    const value = obj[prop];
+    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+      deepFreeze(value);
+    }
+  }
+  return obj;
+}
+__name(deepFreeze, "deepFreeze");
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isObject, "isObject");
+function getAllPaths(obj, parentPath = "") {
+  if (!isObject(obj)) return [];
+  return Object.entries(obj).flatMap(([key, value]) => {
+    const currentPath = parentPath ? `${parentPath}.${key}` : key;
+    if (isObject(value)) {
+      return [
+        currentPath,
+        ...getAllPaths(value, currentPath)
+      ];
+    }
+    return [
+      currentPath
+    ];
+  });
+}
+__name(getAllPaths, "getAllPaths");
+
+export { deepClone, deepFreeze, deepObjMerge, filterObject, flattenObject, getAllPaths, getValueByPath, isEqual, isObjEmpty, isObject, isPlainObject, mapObject, omit, pick, setValueByPath };

package/obj/obj.utils.d.ts

@@ -0,0 +1,156 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * Checks whether the object has no own enumerable properties.
+ *
+ * @param {Record<any, any>} obj - The object to check.
+ * @returns {boolean} True if the object is empty, false otherwise.
+ */
+export declare function isObjEmpty(obj: Record<any, any>): boolean;
+/**
+ * Returns a new object with only the specified keys picked.
+ *
+ * @template T
+ * @template K
+ * @param {T} obj - The source object.
+ * @param {K[]} keys - Keys to pick from the object.
+ * @returns {Pick<T, K>} New object with picked keys.
+ */
+export declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * Returns a new object with the specified keys omitted.
+ *
+ * @template T
+ * @template K
+ * @param {T} obj - The source object.
+ * @param {K[]} keys - Keys to omit from the object.
+ * @returns {Omit<T, K>} New object without omitted keys.
+ */
+export declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * Deeply merges multiple objects into the target object (mutates and returns the target object, not pure).
+ *
+ * @template T
+ * @param {T} target - The object to merge into (will be mutated).
+ * @param {...any[]} sources - The objects to merge from.
+ * @returns {T} The merged object (same as target).
+ */
+export declare function deepObjMerge<T extends object>(target: T, ...sources: any[]): T;
+/**
+ * Checks if a value is a plain object (i.e., not an array, null, or a built-in object).
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a plain object, false otherwise.
+ */
+export declare function isPlainObject(value: any): value is Record<string, any>;
+/**
+ * Flattens a nested object using dot notation for keys (e.g., `{a: {b: 1}}` → `{ "a.b": 1 }`).
+ *
+ * @template T
+ * @param {T} obj - The object to flatten.
+ * @param {string} [prefix=""] - Optional prefix for nested keys (used internally).
+ * @returns {Record<string, any>} A new object with flattened keys.
+ */
+export declare function flattenObject<T extends Record<string, any>>(obj: T, prefix?: string): Record<string, any>;
+/**
+ * Safely gets the value of a deeply nested key in an object using dot/bracket notation path.
+ *
+ * @template T
+ * @param {T} obj - The object to extract from.
+ * @param {string} path - String path using dot and/or bracket notation (e.g., 'user.friends[0].name').
+ * @returns {any} The value at the given path, or undefined if not found.
+ */
+export declare function getValueByPath<T extends object>(obj: T, path: string): any;
+/**
+ * Sets a value at a deeply nested key in an object using dot/bracket notation path.
+ * Secured against prototype pollution.
+ *
+ * @template T
+ * @param {T} obj - The object to modify.
+ * @param {string} path - Dot/bracket notation path (e.g., "user.friends[0].name").
+ * @param {any} value - Value to assign.
+ * @returns {T} The modified object.
+ */
+export declare function setValueByPath<T extends object>(obj: T, path: string, value: any): T;
+/**
+ * Performs a deep equality check between two objects.
+ *
+ * @param {any} a - First value to compare.
+ * @param {any} b - Second value to compare.
+ * @returns {boolean} True if values are deeply equal.
+ */
+export declare function isEqual(a: any, b: any): boolean;
+/**
+ * Filters object properties based on a predicate function.
+ *
+ * @template T
+ * @param {T} obj - The source object.
+ * @param {(value: any, key: string, obj: T) => boolean} predicate - Filter function.
+ * @returns {Partial<T>} New object with filtered properties.
+ */
+export declare function filterObject<T extends object>(obj: T, predicate: (value: any, key: string, obj: T) => boolean): Partial<T>;
+/**
+ * Maps object values to new values using a mapping function.
+ *
+ * @template T
+ * @template U
+ * @param {T} obj - The source object.
+ * @param {(value: any, key: string, obj: T) => U} mapFn - Mapping function.
+ * @returns {Record<keyof T, U>} New object with mapped values.
+ */
+export declare function mapObject<T extends object, U>(obj: T, mapFn: (value: any, key: string, obj: T) => U): Record<keyof T, U>;
+/**
+ * Create a deep clone of a value. Uses structuredClone when available, falls back to JSON
+ * serialization as a best-effort fallback (may lose functions and special objects).
+ *
+ * @template T
+ * @param {T} value
+ * @returns {T}
+ */
+export declare function deepClone<T>(value: T): T;
+/**
+ * Recursively freezes an object and all its properties.
+ * Makes an object immutable.
+ *
+ * @template T
+ * @param {T} obj - The object to freeze.
+ * @returns {Readonly<T>} The frozen object.
+ */
+export declare function deepFreeze<T extends object>(obj: T): Readonly<T>;
+/**
+ * Safely checks if a value is an object (not null, not array).
+ *
+ * @param {unknown} value - Value to check.
+ * @returns {boolean} True if value is a non-null, non-array object.
+ */
+export declare function isObject(value: unknown): value is Record<string, any>;
+/**
+ * Gets all paths in an object using dot notation.
+ *
+ * @param {Record<string, any>} obj - Object to analyze.
+ * @param {string} [parentPath=""] - Internal param for recursion.
+ * @returns {string[]} Array of all paths in dot notation.
+ */
+export declare function getAllPaths(obj: Record<string, any>, parentPath?: string): string[];

package/package.json

@@ -1,50 +1,202 @@
 {
   "name": "@catbee/utils",
-  "version": "1.0.5",
+  "version": "2.0.0-next.0",
   "description": "A modular, production-grade utility toolkit for Node.js and TypeScript, designed for robust, scalable applications (including Express-based services). All utilities are tree-shakable and can be imported independently.",
-  "main": "build/index.cjs",
-  "module": "build/index.mjs",
-  "types": "build/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
-  "author": {
-    "name": "Hari G",
-    "email": "hprasath.dev@gmail.com"
+  "main": "index.cjs",
+  "module": "index.mjs",
+  "types": "index.d.ts",
+  "author": "Hari G <harig@catbee.in>",
+  "maintainers": [
+    "Hari G <harig@catbee.in>",
+    "Bavi R <bavithra@catbee.in>"
+  ],
+  "homepage": "https://catbee.in/docs/@catbee/utils/intro",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/catbee-technologies/catbee-utils.git"
+  },
+  "bugs": {
+    "url": "https://github.com/catbee-technologies/catbee-utils/issues"
   },
   "license": "MIT",
+  "dependencies": {
+    "pino": "^10.1.0",
+    "reflect-metadata": "^0.2.2"
+  },
   "optionalDependencies": {
-    "@scalar/express-api-reference": "^0.8.20",
+    "@scalar/express-api-reference": "^0.8.30",
     "abort-controller": "^3.0.0",
     "compression": "^1.8.1",
     "cookie-parser": "^1.4.7",
     "cors": "^2.8.5",
-    "express-rate-limit": "^8.1.0",
+    "dotenv": "^17.2.3",
+    "express-rate-limit": "^8.2.1",
     "helmet": "^8.1.0",
-    "pino": "^10.0.0",
-    "pino-pretty": "^13.1.1",
+    "pino-pretty": "^13.1.3",
     "prom-client": "^15.1.3"
   },
   "peerDependencies": {
-    "express": "^5.1.0",
-    "reflect-metadata": "^0.2.2"
+    "express": "^5.1.0"
   },
   "peerDependenciesMeta": {
     "express": {
       "optional": true
-    },
-    "reflect-metadata": {
-      "optional": true
     }
   },
   "engines": {
     "node": ">=18.4"
   },
   "files": [
-    "build/**/*.mjs",
-    "build/**/*.cjs",
-    "build/**/*.d.ts",
+    "**/*.mjs",
+    "**/*.cjs",
+    "**/*.d.ts",
+    "**/*.d.mts",
     "LICENSE",
     "README.md"
-  ]
+  ],
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.cjs",
+      "types": "./index.d.ts"
+    },
+    "./array": {
+      "import": "./array/index.mjs",
+      "require": "./array/index.cjs",
+      "types": "./array/index.d.ts"
+    },
+    "./async": {
+      "import": "./async/index.mjs",
+      "require": "./async/index.cjs",
+      "types": "./async/index.d.ts"
+    },
+    "./cache": {
+      "import": "./cache/index.mjs",
+      "require": "./cache/index.cjs",
+      "types": "./cache/index.d.ts"
+    },
+    "./config": {
+      "import": "./config/index.mjs",
+      "require": "./config/index.cjs",
+      "types": "./config/index.d.ts"
+    },
+    "./context-store": {
+      "import": "./context-store/index.mjs",
+      "require": "./context-store/index.cjs",
+      "types": "./context-store/index.d.ts"
+    },
+    "./crypto": {
+      "import": "./crypto/index.mjs",
+      "require": "./crypto/index.cjs",
+      "types": "./crypto/index.d.ts"
+    },
+    "./date": {
+      "import": "./date/index.mjs",
+      "require": "./date/index.cjs",
+      "types": "./date/index.d.ts"
+    },
+    "./decorators": {
+      "import": "./decorators/index.mjs",
+      "require": "./decorators/index.cjs",
+      "types": "./decorators/index.d.ts"
+    },
+    "./dir": {
+      "import": "./dir/index.mjs",
+      "require": "./dir/index.cjs",
+      "types": "./dir/index.d.ts"
+    },
+    "./env": {
+      "import": "./env/index.mjs",
+      "require": "./env/index.cjs",
+      "types": "./env/index.d.ts"
+    },
+    "./exception": {
+      "import": "./exception/index.mjs",
+      "require": "./exception/index.cjs",
+      "types": "./exception/index.d.ts"
+    },
+    "./fs": {
+      "import": "./fs/index.mjs",
+      "require": "./fs/index.cjs",
+      "types": "./fs/index.d.ts"
+    },
+    "./http-status-codes": {
+      "import": "./http-status-codes/index.mjs",
+      "require": "./http-status-codes/index.cjs",
+      "types": "./http-status-codes/index.d.ts"
+    },
+    "./id": {
+      "import": "./id/index.mjs",
+      "require": "./id/index.cjs",
+      "types": "./id/index.d.ts"
+    },
+    "./logger": {
+      "import": "./logger/index.mjs",
+      "require": "./logger/index.cjs",
+      "types": "./logger/index.d.ts"
+    },
+    "./middleware": {
+      "import": "./middleware/index.mjs",
+      "require": "./middleware/index.cjs",
+      "types": "./middleware/index.d.ts"
+    },
+    "./obj": {
+      "import": "./obj/index.mjs",
+      "require": "./obj/index.cjs",
+      "types": "./obj/index.d.ts"
+    },
+    "./performance": {
+      "import": "./performance/index.mjs",
+      "require": "./performance/index.cjs",
+      "types": "./performance/index.d.ts"
+    },
+    "./request": {
+      "import": "./request/index.mjs",
+      "require": "./request/index.cjs",
+      "types": "./request/index.d.ts"
+    },
+    "./response": {
+      "import": "./response/index.mjs",
+      "require": "./response/index.cjs",
+      "types": "./response/index.d.ts"
+    },
+    "./server": {
+      "import": "./server/index.mjs",
+      "require": "./server/index.cjs",
+      "types": "./server/index.d.ts"
+    },
+    "./stream": {
+      "import": "./stream/index.mjs",
+      "require": "./stream/index.cjs",
+      "types": "./stream/index.d.ts"
+    },
+    "./string": {
+      "import": "./string/index.mjs",
+      "require": "./string/index.cjs",
+      "types": "./string/index.d.ts"
+    },
+    "./type": {
+      "import": "./type/index.mjs",
+      "require": "./type/index.cjs",
+      "types": "./type/index.d.ts"
+    },
+    "./types": {
+      "import": "./types/index.mjs",
+      "require": "./types/index.cjs",
+      "types": "./types/index.d.ts"
+    },
+    "./url": {
+      "import": "./url/index.mjs",
+      "require": "./url/index.cjs",
+      "types": "./url/index.d.ts"
+    },
+    "./validate": {
+      "import": "./validate/index.mjs",
+      "require": "./validate/index.cjs",
+      "types": "./validate/index.d.ts"
+    }
+  }
 }