@cyberskill/shared 2.28.0 → 3.1.0

package/dist/util/object/object.util.js

@@ -1,103 +1,99 @@
-var A = Object.defineProperty, m = Object.defineProperties, d = Object.getOwnPropertyDescriptors, f = Object.getOwnPropertySymbols, v = Object.prototype.hasOwnProperty, w = Object.prototype.propertyIsEnumerable, u = (e, r, n) => r in e ? A(e, r, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[r] = n, y = (e, r) => {
-  for (var n in r || (r = {}))
-    v.call(r, n) && u(e, n, r[n]);
-  if (f)
-    for (var n of f(r))
-      w.call(r, n) && u(e, n, r[n]);
-  return e;
-}, p = (e, r) => m(e, d(r));
-function P(e) {
+function p(e) {
   try {
     return JSON.parse(e), !0;
-  } catch (r) {
+  } catch {
     return !1;
   }
 }
-function _(e, r) {
+function A(e, t) {
   let n = e;
-  const o = r.length;
-  for (let t = 0; t < o; t++) {
-    const s = r[t];
-    if (s !== void 0 && n && typeof n == "object" && s in n)
+  const o = t.length;
+  for (let r = 0; r < o; r++) {
+    if (n == null || typeof n != "object")
+      return;
+    const s = t[r];
+    if (s !== void 0 && s in n)
       n = n[s];
     else
       return;
   }
   return n;
 }
-function g(e, r, n, o) {
-  if (o >= r.length)
+function f(e, t, n, o) {
+  if (o >= t.length)
     return e;
-  const t = r[o];
-  if (o === r.length - 1)
-    return p(y({}, e), {
-      [t]: n
-    });
-  const s = e[t];
-  return p(y({}, e), {
-    [t]: g(
+  const r = t[o];
+  if (o === t.length - 1)
+    return {
+      ...e,
+      [r]: n
+    };
+  const s = e[r];
+  return {
+    ...e,
+    [r]: f(
       typeof s == "object" && s !== null ? s : {},
-      r,
+      t,
       n,
       o + 1
     )
-  });
+  };
 }
-function b(e, r, n) {
-  return r.length === 0 ? e : g(e, r, n, 0);
+function g(e, t, n) {
+  return t.length === 0 ? e : f(e, t, n, 0);
 }
-function O(e) {
+function u(e) {
   if (e === null || typeof e != "object")
     return e;
   if (Array.isArray(e))
-    return e.map((o) => O(o));
+    return e.map((o) => u(o));
   if (e instanceof Date)
     return new Date(e.getTime());
   if (e instanceof RegExp)
     return new RegExp(e.source, e.flags);
-  const r = Object.getPrototypeOf(e);
-  if (r !== Object.prototype && r !== null)
+  const t = Object.getPrototypeOf(e);
+  if (t !== Object.prototype && t !== null)
     return e;
   const n = {};
   for (const o in e)
-    Object.prototype.hasOwnProperty.call(e, o) && (n[o] = O(e[o]));
+    Object.prototype.hasOwnProperty.call(e, o) && (n[o] = u(e[o]));
   return n;
 }
-function h(...e) {
+function y(...e) {
   if (e.length === 0)
     return {};
-  const r = e.filter((t) => t != null);
-  if (r.length === 0)
+  const t = e.filter((r) => r != null);
+  if (t.length === 0)
     return {};
-  if (r.length === 1)
-    return r[0];
-  if (r.every(Array.isArray))
-    return [].concat(...r);
-  if (r.every((t) => typeof t == "object" && t !== null && !Array.isArray(t))) {
-    const t = {};
-    for (const s of r) {
-      const l = s;
-      for (const a in l)
-        if (Object.prototype.hasOwnProperty.call(l, a)) {
-          const i = l[a];
-          if (Object.prototype.hasOwnProperty.call(t, a)) {
-            const c = t[a];
-            typeof i == "object" && i !== null && typeof c == "object" && c !== null ? Array.isArray(i) && Array.isArray(c) ? t[a] = c.concat(i) : !Array.isArray(i) && !Array.isArray(c) ? t[a] = h(
+  if (t.length === 1)
+    return t[0];
+  if (t.every(Array.isArray))
+    return [].concat(...t);
+  if (t.every((r) => typeof r == "object" && r !== null && !Array.isArray(r))) {
+    const r = {};
+    for (const s of t) {
+      const i = s;
+      for (const l in i)
+        if (Object.prototype.hasOwnProperty.call(i, l)) {
+          const a = i[l];
+          if (Object.prototype.hasOwnProperty.call(r, l)) {
+            const c = r[l];
+            typeof a == "object" && a !== null && typeof c == "object" && c !== null ? Array.isArray(a) && Array.isArray(c) ? r[l] = c.concat(a) : !Array.isArray(a) && !Array.isArray(c) ? r[l] = y(
               c,
-              i
-            ) : t[a] = i : t[a] = i;
+              a
+            ) : r[l] = a : r[l] = a;
           } else
-            t[a] = i;
+            r[l] = a;
         }
     }
-    return t;
+    return r;
   }
-  if (r.every((t) => typeof t != "object" || t === null))
+  if (t.every((r) => typeof r != "object" || r === null))
     throw new Error(
       "deepMerge: Cannot merge primitive values. All arguments must be objects or arrays."
     );
-  const n = r.some(Array.isArray), o = r.some(
-    (t) => typeof t == "object" && t !== null && !Array.isArray(t)
+  const n = t.some(Array.isArray), o = t.some(
+    (r) => typeof r == "object" && r !== null && !Array.isArray(r)
   );
   throw n && o ? new Error(
     "deepMerge: Cannot mix arrays and objects. All arguments must be either arrays or objects."
@@ -105,34 +101,35 @@ function h(...e) {
     "deepMerge: Invalid arguments provided. All arguments must be objects or arrays of the same type."
   );
 }
-function j(e) {
+function h(e) {
   if (!e || typeof e != "object")
     return e;
-  const r = {};
-  function n(o, t) {
+  const t = {};
+  function n(o, r) {
     for (const s in o) {
       if (!Object.prototype.hasOwnProperty.call(o, s))
         continue;
-      const l = o[s], a = t ? `${t}.${s}` : s;
-      if (l && typeof l == "object" && !Array.isArray(l)) {
-        let i = !1;
-        for (const c in l)
-          if (Object.prototype.hasOwnProperty.call(l, c) && c.startsWith("$")) {
-            i = !0;
+      const i = o[s], l = r ? `${r}.${s}` : s;
+      if (i && typeof i == "object" && !Array.isArray(i)) {
+        let a = !1;
+        for (const c in i)
+          if (Object.prototype.hasOwnProperty.call(i, c) && c.startsWith("$")) {
+            a = !0;
             break;
           }
-        i ? r[a] = l : n(l, a);
+        a ? t[l] = i : n(i, l);
       } else
-        r[a] = l;
+        t[l] = i;
     }
   }
-  return n(e, ""), r;
+  return n(e, ""), t;
 }
 export {
-  O as deepClone,
-  h as deepMerge,
-  _ as getNestedValue,
-  P as isJSON,
-  j as normalizeMongoFilter,
-  b as setNestedValue
+  u as deepClone,
+  y as deepMerge,
+  A as getNestedValue,
+  p as isJSON,
+  h as normalizeMongoFilter,
+  g as setNestedValue
 };
+//# sourceMappingURL=object.util.js.map

package/dist/util/object/object.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.util.js","sources":["../../../src/util/object/object.util.ts"],"sourcesContent":["/**\n * Check if a string is a valid JSON string.\n * This function attempts to parse the string as JSON and returns true if successful,\n * false if the string is not valid JSON.\n *\n * @param str - The string to check for valid JSON format.\n * @returns True if the string is a valid JSON string, false otherwise.\n */\nexport function isJSON(str: string): boolean {\n    try {\n        JSON.parse(str);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n\n/**\n * Gets a nested value from an object using a path array.\n * This function traverses the object following the provided path and returns\n * the value at the specified location, or undefined if the path doesn't exist.\n *\n * @param obj - The object to get the value from.\n * @param path - An array of keys representing the path to the desired value.\n * @returns The value at the specified path, or undefined if the path doesn't exist.\n */\nexport function getNestedValue<T>(obj: T, path: (string | number)[]): unknown {\n    // Optimization: Loop is faster than reduce and allows early exit\n    let current: unknown = obj;\n    const len = path.length;\n\n    for (let i = 0; i < len; i++) {\n        // Optimization: Early return if current value is null/undefined or not an object\n        // This avoids unnecessary key lookups and type checks\n        if (current == null || typeof current !== 'object') {\n            return undefined;\n        }\n\n        const key = path[i];\n\n        if (key !== undefined && key in (current as Record<string | number, unknown>)) {\n            current = (current as Record<string | number, unknown>)[key];\n        }\n        else {\n            return undefined;\n        }\n    }\n\n    return current;\n}\n\nfunction setNestedValueHelper<T>(obj: T, path: (string | number)[], value: unknown, index: number): T {\n    if (index >= path.length)\n        return obj;\n\n    const head = path[index];\n\n    if (index === path.length - 1) {\n        return {\n            ...(obj as Record<string | number, unknown>),\n            [head as string | number]: value,\n        } as T;\n    }\n\n    const current = (obj as Record<string | number, unknown>)[head as string | number];\n\n    return {\n        ...(obj as Record<string | number, unknown>),\n        [head as string | number | symbol]: setNestedValueHelper(\n            typeof current === 'object' && current !== null\n                ? (current as object)\n                : {},\n            path,\n            value,\n            index + 1,\n        ),\n    } as T;\n}\n\n/**\n * Sets a nested value in an object using a path array.\n * This function creates the path if it doesn't exist and sets the value at the specified location.\n * The function returns a new object with the updated value, maintaining immutability.\n *\n * @param obj - The object to set the value in.\n * @param path - An array of keys representing the path to the desired location.\n * @param value - The value to set at the specified path.\n * @returns A new object with the updated value at the specified path.\n */\nexport function setNestedValue<T>(obj: T, path: (string | number)[], value: unknown): T {\n    if (path.length === 0)\n        return obj;\n\n    return setNestedValueHelper(obj, path, value, 0);\n}\n\n/**\n * Deep clones an object or array.\n * This function creates a deep copy of the input, recursively cloning objects and arrays.\n * Primitive values, dates, and other non-plain objects are returned as is (or cloned if supported).\n * Note: This implementation focuses on plain objects and arrays. For complex types like Map/Set/Buffer/ObjectId,\n * it returns the reference or handles them according to specific logic.\n *\n * @param obj - The object to clone.\n * @returns A deep copy of the object.\n */\nexport function deepClone<T>(obj: T): T {\n    if (obj === null || typeof obj !== 'object') {\n        return obj;\n    }\n\n    if (Array.isArray(obj)) {\n        return obj.map(item => deepClone(item)) as unknown as T;\n    }\n\n    if (obj instanceof Date) {\n        return new Date(obj.getTime()) as unknown as T;\n    }\n\n    if (obj instanceof RegExp) {\n        return new RegExp(obj.source, obj.flags) as unknown as T;\n    }\n\n    // Handle Mongoose ObjectId and other custom classes by returning reference\n    // structuredClone would fail here. We assume if it's not a plain object, we keep the reference\n    // unless we want to implement specific cloning logic for every type.\n    // However, we want to clone POJOs (Plain Old JavaScript Objects).\n    const proto = Object.getPrototypeOf(obj);\n    if (proto !== Object.prototype && proto !== null) {\n        return obj;\n    }\n\n    const result = {} as Record<string, unknown>;\n    for (const key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            result[key] = deepClone((obj as Record<string, unknown>)[key]);\n        }\n    }\n\n    return result as T;\n}\n\n/**\n * Deep merges multiple objects into a single object.\n * @param args - The objects to merge. Can be empty, in which case returns an empty object.\n * @returns The merged object.\n */\nexport function deepMerge<T = Record<string, unknown>>(\n    ...args: (object | null | undefined)[]\n): T;\n\n/**\n * Deep merges multiple arrays into a single array.\n * @param args - The arrays to merge. Can be empty, in which case returns an empty array.\n * @returns The merged array.\n */\nexport function deepMerge<T = unknown[]>(\n    ...args: (unknown[] | null | undefined)[]\n): T;\n\n/**\n * Implementation of deepMerge function.\n * @param args - The objects or arrays to merge.\n * @returns The merged result.\n */\nexport function deepMerge<T = Record<string, unknown> | unknown[]>(\n    ...args: (object | unknown[] | null | undefined)[]\n): T {\n    // Handle empty arguments\n    if (args.length === 0) {\n        return {} as T;\n    }\n\n    // Filter out null/undefined and convert to empty objects/arrays\n    const validArgs = args.filter((arg): arg is object => arg !== null && arg !== undefined);\n\n    // If no valid arguments after filtering, return empty object/array\n    if (validArgs.length === 0) {\n        return {} as T;\n    }\n\n    // If only one argument, return it directly\n    if (validArgs.length === 1) {\n        return validArgs[0] as T;\n    }\n\n    // Check if all arguments are arrays\n    if (validArgs.every(Array.isArray)) {\n        return ([] as unknown[]).concat(...validArgs) as T;\n    }\n\n    // Check if all arguments are objects (but not arrays)\n    if (validArgs.every(arg => typeof arg === 'object' && arg !== null && !Array.isArray(arg))) {\n        const result = {} as Record<string, unknown>;\n\n        for (const arg of validArgs) {\n            const obj = arg as Record<string, unknown>;\n            for (const key in obj) {\n                if (Object.prototype.hasOwnProperty.call(obj, key)) {\n                    const value = obj[key];\n                    if (Object.prototype.hasOwnProperty.call(result, key)) {\n                        const existingValue = result[key];\n                        if (\n                            typeof value === 'object' && value !== null\n                            && typeof existingValue === 'object' && existingValue !== null\n                        ) {\n                            if (Array.isArray(value) && Array.isArray(existingValue)) {\n                                result[key] = existingValue.concat(value);\n                            }\n                            else if (!Array.isArray(value) && !Array.isArray(existingValue)) {\n                                result[key] = deepMerge(\n                                    existingValue as Record<string, unknown>,\n                                    value as Record<string, unknown>,\n                                );\n                            }\n                            else {\n                                // One is array, other is object (shouldn't happen with strict types but possible)\n                                // Overwrite\n                                result[key] = value;\n                            }\n                        }\n                        else {\n                            result[key] = value;\n                        }\n                    }\n                    else {\n                        result[key] = value;\n                    }\n                }\n            }\n        }\n        return result as T;\n    }\n\n    // Check if all arguments are primitive values\n    if (validArgs.every(arg => typeof arg !== 'object' || arg === null)) {\n        throw new Error(\n            'deepMerge: Cannot merge primitive values. All arguments must be objects or arrays.',\n        );\n    }\n\n    // Mixed types error\n    const hasArrays = validArgs.some(Array.isArray);\n    const hasObjects = validArgs.some(arg =>\n        typeof arg === 'object' && arg !== null && !Array.isArray(arg),\n    );\n\n    if (hasArrays && hasObjects) {\n        throw new Error(\n            'deepMerge: Cannot mix arrays and objects. All arguments must be either arrays or objects.',\n        );\n    }\n\n    // Fallback for unexpected cases\n    throw new Error(\n        'deepMerge: Invalid arguments provided. All arguments must be objects or arrays of the same type.',\n    );\n}\n\n/**\n * Normalizes MongoDB filters to support both dot notation strings and nested objects.\n * This function converts nested object filters to dot notation format while preserving\n * MongoDB operators to ensure consistent behavior across different filter input formats.\n *\n * @param filter - The filter object to normalize.\n * @returns A normalized filter object with nested objects converted to dot notation,\n *          while preserving MongoDB operators as nested objects.\n *\n * @example\n * ```typescript\n * // Both of these will work the same way:\n * normalizeMongoFilter({ \"location.countryId\": \"240\" })\n * normalizeMongoFilter({ location: { countryId: \"240\" } })\n * // Both return: { \"location.countryId\": \"240\" }\n *\n * // MongoDB operators are preserved:\n * normalizeMongoFilter({ id: { $in: [\"240\", \"59\"] } })\n * // Returns: { id: { $in: [\"240\", \"59\"] } }\n * ```\n */\nexport function normalizeMongoFilter<T extends Record<string, unknown>>(filter: T): T {\n    if (!filter || typeof filter !== 'object') {\n        return filter;\n    }\n\n    const normalized: Record<string, unknown> = {};\n\n    /**\n     *\n     */\n    function flatten(current: Record<string, unknown>, prefix: string) {\n        for (const key in current) {\n            if (!Object.prototype.hasOwnProperty.call(current, key))\n                continue;\n\n            const value = current[key];\n            const newKey = prefix ? `${prefix}.${key}` : key;\n\n            if (value && typeof value === 'object' && !Array.isArray(value)) {\n                // Check for Mongo operator\n                let hasMongoOperator = false;\n                for (const subKey in value as Record<string, unknown>) {\n                    if (Object.prototype.hasOwnProperty.call(value, subKey) && subKey.startsWith('$')) {\n                        hasMongoOperator = true;\n                        break;\n                    }\n                }\n\n                if (hasMongoOperator) {\n                    normalized[newKey] = value;\n                }\n                else {\n                    flatten(value as Record<string, unknown>, newKey);\n                }\n            }\n            else {\n                normalized[newKey] = value;\n            }\n        }\n    }\n\n    flatten(filter, '');\n\n    return normalized as T;\n}\n"],"names":["isJSON","str","getNestedValue","obj","path","current","len","i","key","setNestedValueHelper","value","index","head","setNestedValue","deepClone","item","proto","result","deepMerge","args","validArgs","arg","existingValue","hasArrays","hasObjects","normalizeMongoFilter","filter","normalized","flatten","prefix","newKey","hasMongoOperator","subKey"],"mappings":"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"}

package/dist/util/serializer/index.js

@@ -2,3 +2,4 @@ import { serializer as i } from "./serializer.util.js";
 export {
   i as serializer
 };
+//# sourceMappingURL=index.js.map

package/dist/util/serializer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/util/serializer/serializer.util.js

@@ -76,3 +76,4 @@ const n = {
 export {
   p as serializer
 };
+//# sourceMappingURL=serializer.util.js.map

package/dist/util/serializer/serializer.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.util.js","sources":["../../../src/util/serializer/serializer.util.ts"],"sourcesContent":["import type {\n    I_Serializer,\n    I_SerializerTypeWrapper,\n    I_SerializerValueMap,\n    T_SerializerKnownTypes,\n} from './serializer.type.js';\n\n/**\n * Interface for handling serialization and deserialization of specific types.\n * Each handler provides methods to check if a value is of the specific type,\n * serialize it to a format that can be JSON stringified, and deserialize it back.\n */\ninterface I_Handler<T extends T_SerializerKnownTypes> {\n    /** Checks if a value is of the specific type */\n    is: (value: unknown) => value is I_SerializerValueMap[T];\n    /** Serializes a value of the specific type to a format that can be JSON stringified */\n    serialize: (value: I_SerializerValueMap[T]) => I_SerializerTypeWrapper<T>;\n    /** Deserializes a value back to the specific type */\n    deserialize: (value: unknown) => I_SerializerValueMap[T];\n}\n\n/**\n * Type handlers for different JavaScript types that cannot be directly serialized to JSON.\n * Each handler provides methods to serialize and deserialize specific types like Date, Map, Set, etc.\n */\nconst typeHandlers: {\n    [K in T_SerializerKnownTypes]: I_Handler<K>;\n} = {\n    Date: {\n        is: (v): v is Date => v instanceof Date,\n        serialize: v => ({ __type: 'Date', value: v.toISOString() }),\n        deserialize: v => new Date(v as string),\n    },\n    Map: {\n        is: (v): v is Map<unknown, unknown> => v instanceof Map,\n        serialize: v => ({ __type: 'Map', value: Array.from(v.entries()) }),\n        deserialize: v => new Map(v as [unknown, unknown][]),\n    },\n    Set: {\n        is: (v): v is Set<unknown> => v instanceof Set,\n        serialize: v => ({ __type: 'Set', value: Array.from(v) }),\n        deserialize: v => new Set(v as unknown[]),\n    },\n    RegExp: {\n        is: (v): v is RegExp => v instanceof RegExp,\n        serialize: v => ({\n            __type: 'RegExp',\n            value: { source: v.source, flags: v.flags },\n        }),\n        deserialize: (v) => {\n            const { source, flags } = v as { source: string; flags: string };\n            return new RegExp(source, flags);\n        },\n    },\n    BigInt: {\n        is: (v): v is bigint => typeof v === 'bigint',\n        serialize: v => ({ __type: 'BigInt', value: v.toString() }),\n        deserialize: v => BigInt(v as string),\n    },\n};\n\n/**\n * A serializer that can handle complex JavaScript types that cannot be directly JSON stringified.\n * This serializer extends JSON.stringify and JSON.parse to handle types like Date, Map, Set, RegExp, and BigInt.\n *\n * The serializer works by:\n * 1. During serialization: Wrapping special types with type information before JSON stringification\n * 2. During deserialization: Detecting wrapped types and reconstructing them to their original form\n */\nexport const serializer: I_Serializer<unknown> = {\n    /**\n     * Serializes a value to a JSON string.\n     * If the value is of a known type (Date, Map, Set, RegExp, BigInt),\n     * it will be serialized using the corresponding handler.\n     * Otherwise, it will be serialized as is.\n     *\n     * @param value - The value to serialize to a JSON string.\n     * @returns The serialized JSON string that can be safely stored or transmitted.\n     */\n    serialize(value) {\n        return JSON.stringify(value, function (_key, val) {\n            // eslint-disable-next-line ts/no-this-alias\n            const context = this;\n            const originalValue = context[_key];\n\n            if (originalValue instanceof Date) {\n                return typeHandlers.Date.serialize(originalValue);\n            }\n\n            for (const type of Object.keys(typeHandlers) as T_SerializerKnownTypes[]) {\n                const handler = typeHandlers[type];\n\n                if (handler.is(val)) {\n                    return (handler as I_Handler<typeof type>).serialize(val);\n                }\n            }\n\n            return val;\n        });\n    },\n    /**\n     * Deserializes a JSON string to its original value.\n     * If the value is of a known type (Date, Map, Set, RegExp, BigInt),\n     * it will be deserialized using the corresponding handler.\n     * Otherwise, it will be deserialized as is.\n     *\n     * @param json - The JSON string to deserialize back to its original form.\n     * @returns The deserialized value with all special types reconstructed.\n     */\n    deserialize(json) {\n        return JSON.parse(json, (_key, val) => {\n            if (\n                val\n                && typeof val === 'object'\n                && '__type' in val\n                && typeof val.__type === 'string'\n            ) {\n                const type = val.__type as T_SerializerKnownTypes;\n                const handler = typeHandlers[type];\n\n                if (handler) {\n                    return handler.deserialize(val.value);\n                }\n            }\n            return val;\n        });\n    },\n};\n"],"names":["typeHandlers","v","source","flags","serializer","value","_key","val","originalValue","type","handler","json"],"mappings":"AAyBA,MAAMA,IAEF;AAAA,EACA,MAAM;AAAA,IACF,IAAI,CAACC,MAAiBA,aAAa;AAAA,IACnC,WAAW,QAAM,EAAE,QAAQ,QAAQ,OAAOA,EAAE;IAC5C,aAAa,CAAAA,MAAK,IAAI,KAAKA,CAAW;AAAA,EAAA;AAAA,EAE1C,KAAK;AAAA,IACD,IAAI,CAACA,MAAkCA,aAAa;AAAA,IACpD,WAAW,CAAAA,OAAM,EAAE,QAAQ,OAAO,OAAO,MAAM,KAAKA,EAAE,QAAA,CAAS,EAAA;AAAA,IAC/D,aAAa,CAAAA,MAAK,IAAI,IAAIA,CAAyB;AAAA,EAAA;AAAA,EAEvD,KAAK;AAAA,IACD,IAAI,CAACA,MAAyBA,aAAa;AAAA,IAC3C,WAAW,QAAM,EAAE,QAAQ,OAAO,OAAO,MAAM,KAAKA,CAAC;IACrD,aAAa,CAAAA,MAAK,IAAI,IAAIA,CAAc;AAAA,EAAA;AAAA,EAE5C,QAAQ;AAAA,IACJ,IAAI,CAACA,MAAmBA,aAAa;AAAA,IACrC,WAAW,CAAAA,OAAM;AAAA,MACb,QAAQ;AAAA,MACR,OAAO,EAAE,QAAQA,EAAE,QAAQ,OAAOA,EAAE,MAAA;AAAA,IAAM;AAAA,IAE9C,aAAa,CAACA,MAAM;AAChB,YAAM,EAAE,QAAAC,GAAQ,OAAAC,EAAA,IAAUF;AAC1B,aAAO,IAAI,OAAOC,GAAQC,CAAK;AAAA,IACnC;AAAA,EAAA;AAAA,EAEJ,QAAQ;AAAA,IACJ,IAAI,CAACF,MAAmB,OAAOA,KAAM;AAAA,IACrC,WAAW,QAAM,EAAE,QAAQ,UAAU,OAAOA,EAAE;IAC9C,aAAa,CAAAA,MAAK,OAAOA,CAAW;AAAA,EAAA;AAE5C,GAUaG,IAAoC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAU7C,UAAUC,GAAO;AACb,WAAO,KAAK,UAAUA,GAAO,SAAUC,GAAMC,GAAK;AAG9C,YAAMC,IADU,KACcF,CAAI;AAElC,UAAIE,aAAyB;AACzB,eAAOR,EAAa,KAAK,UAAUQ,CAAa;AAGpD,iBAAWC,KAAQ,OAAO,KAAKT,CAAY,GAA+B;AACtE,cAAMU,IAAUV,EAAaS,CAAI;AAEjC,YAAIC,EAAQ,GAAGH,CAAG;AACd,iBAAQG,EAAmC,UAAUH,CAAG;AAAA,MAEhE;AAEA,aAAOA;AAAA,IACX,CAAC;AAAA,EACL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,YAAYI,GAAM;AACd,WAAO,KAAK,MAAMA,GAAM,CAACL,GAAMC,MAAQ;AACnC,UACIA,KACG,OAAOA,KAAQ,YACf,YAAYA,KACZ,OAAOA,EAAI,UAAW,UAC3B;AACE,cAAME,IAAOF,EAAI,QACXG,IAAUV,EAAaS,CAAI;AAEjC,YAAIC;AACA,iBAAOA,EAAQ,YAAYH,EAAI,KAAK;AAAA,MAE5C;AACA,aAAOA;AAAA,IACX,CAAC;AAAA,EACL;AACJ;"}

package/dist/util/string/index.js

@@ -1,8 +1,10 @@
-import { generateRandomPassword as t, generateShortId as a, generateSlug as g, getFileName as n, substringBetween as o } from "./string.util.js";
+import { generateRandomPassword as t, generateRandomString as n, generateShortId as a, generateSlug as g, getFileName as o, substringBetween as d } from "./string.util.js";
 export {
   t as generateRandomPassword,
+  n as generateRandomString,
   a as generateShortId,
   g as generateSlug,
-  n as getFileName,
-  o as substringBetween
+  o as getFileName,
+  d as substringBetween
 };
+//# sourceMappingURL=index.js.map

package/dist/util/string/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/util/string/string.util.d.ts

@@ -28,8 +28,20 @@ export declare function generateShortId(uuid: string, length?: number): string;
  *
  * @param length - The desired length of the password (default: 8 characters).
  * @returns A randomly generated password string with the specified length.
+ * @throws {RangeError} If `length` is not a non-negative safe integer.
  */
 export declare function generateRandomPassword(length?: number): string;
+/**
+ * Generates a random string of a given length using a secure random number generator.
+ * This function is a cryptographically secure alternative to Math.random().toString(36).
+ *
+ * @param length - The desired length of the string (default: 8 characters).
+ * @param charset - The characters to use (default: lowercase alphanumeric).
+ * @returns A randomly generated string.
+ * @throws {RangeError} If `length` is not a non-negative safe integer.
+ * @throws {RangeError} If `charset` is empty or exceeds 2^32 characters.
+ */
+export declare function generateRandomString(length?: number, charset?: string): string;
 /**
  * Get the file name from a URL.
  * This function extracts the file name from a URL, optionally including or excluding

package/dist/util/string/string.util.js

@@ -1,50 +1,70 @@
 import { removeAccent as c } from "../common/common.util.js";
-function l(t, r) {
-  let e = t.trim();
-  return e = c(e), (r == null ? void 0 : r.lower) !== !1 && (e = e.toLowerCase()), e = e.replace(/[^a-z0-9\s-]/gi, " "), e = e.replace(/[\s-]+/g, "-"), e = e.replace(/^-+|-+$/g, ""), e;
-}
-function a(t, r) {
-  const e = (n) => l(n != null ? n : "", r);
-  if (typeof t == "object" && t !== null) {
-    const n = {};
-    for (const [o, s] of Object.entries(t))
-      n[o] = e(s);
-    return n;
+function u(e, n) {
+  let t = e.trim();
+  return t = c(t), n?.lower !== !1 && (t = t.toLowerCase()), t = t.replace(/[^a-z0-9\s-]/gi, " "), t = t.replace(/[\s-]+/g, "-"), t = t.replace(/^-+|-+$/g, ""), t;
+}
+function m(e, n) {
+  const t = (r) => u(r ?? "", n);
+  if (typeof e == "object" && e !== null) {
+    const r = {};
+    for (const [o, i] of Object.entries(e))
+      r[o] = t(i);
+    return r;
+  }
+  return t(e);
+}
+function h(e, n = 4) {
+  let t = 2166136261;
+  for (let o = 0; o < e.length; o++)
+    t ^= e.charCodeAt(o), t = Math.imul(t, 16777619);
+  const r = (t >>> 0).toString(16).padStart(8, "0");
+  return n > 8 ? e.replace(/-/g, "").slice(0, n) : r.slice(0, n);
+}
+function f(e, n) {
+  const t = Math.floor(4294967296 / n.length) * n.length, r = [], o = 16384;
+  for (; r.length < e; ) {
+    const i = e - r.length, l = i > o ? o : i, s = new Uint32Array(l);
+    crypto.getRandomValues(s);
+    for (const a of s) {
+      if (r.length >= e)
+        break;
+      a < t && r.push(n[a % n.length]);
+    }
   }
-  return e(t);
-}
-function f(t, r = 4) {
-  let e = 2166136261;
-  for (let o = 0; o < t.length; o++)
-    e ^= t.charCodeAt(o), e = Math.imul(e, 16777619);
-  const n = (e >>> 0).toString(16).padStart(8, "0");
-  return r > 8 ? t.replace(/-/g, "").slice(0, r) : n.slice(0, r);
-}
-function u(t = 8) {
-  const r = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+[]{}|;:,.<>?";
-  return Array.from({ length: t }, () => {
-    const e = Math.floor(Math.random() * r.length);
-    return r.charAt(e);
-  }).join("");
-}
-function g(t = "", r = !1) {
-  const e = t.split(/[?#]/)[0] || "", n = e.substring(e.lastIndexOf("/") + 1);
-  if (r)
-    return n;
-  const o = n.lastIndexOf(".");
-  return o > 0 ? n.slice(0, o) : n;
-}
-function d(t, r, e) {
-  const n = t.indexOf(r);
-  if (n === -1)
+  return r.join("");
+}
+function d(e = 8) {
+  if (!Number.isSafeInteger(e) || e < 0)
+    throw new RangeError("length must be a non-negative safe integer");
+  return f(e, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+[]{}|;:,.<>?");
+}
+function w(e = 8, n = "abcdefghijklmnopqrstuvwxyz0123456789") {
+  if (!Number.isSafeInteger(e) || e < 0)
+    throw new RangeError("length must be a non-negative safe integer");
+  if (n.length === 0 || n.length > 2 ** 32)
+    throw new RangeError("charset.length must be between 1 and 2^32");
+  return f(e, n);
+}
+function b(e = "", n = !1) {
+  const t = e.split(/[?#]/)[0] || "", r = t.substring(t.lastIndexOf("/") + 1);
+  if (n)
+    return r;
+  const o = r.lastIndexOf(".");
+  return o > 0 ? r.slice(0, o) : r;
+}
+function p(e, n, t) {
+  const r = e.indexOf(n);
+  if (r === -1)
     return "";
-  const o = n + r.length, s = t.indexOf(e, o);
-  return s === -1 ? "" : t.slice(o, s);
+  const o = r + n.length, i = e.indexOf(t, o);
+  return i === -1 ? "" : e.slice(o, i);
 }
 export {
-  u as generateRandomPassword,
-  f as generateShortId,
-  a as generateSlug,
-  g as getFileName,
-  d as substringBetween
+  d as generateRandomPassword,
+  w as generateRandomString,
+  h as generateShortId,
+  m as generateSlug,
+  b as getFileName,
+  p as substringBetween
 };
+//# sourceMappingURL=string.util.js.map

package/dist/util/string/string.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.util.js","sources":["../../../src/util/string/string.util.ts"],"sourcesContent":["import type { T_Object } from '#typescript/index.js';\n\nimport type { I_SlugifyOptions } from './string.type.js';\n\nimport { removeAccent } from '../common/common.util.js';\n\n/**\n * Generates a slug from a string.\n * The slug is a URL-friendly version of the string, removing special characters\n * and converting spaces to hyphens.\n *\n * @param input - The string to be slugified.\n * @param options - Options for slugification.\n * @returns The slugified string.\n */\nfunction slugify(input: string, options?: I_SlugifyOptions): string {\n    let slug = input.trim();\n\n    // 1. Remove accents\n    slug = removeAccent(slug);\n\n    // 2. To lower case if requested (default true)\n    if (options?.lower !== false) {\n        slug = slug.toLowerCase();\n    }\n\n    // 3. Replace invalid characters with space (keeping alphanumeric, hyphens, and spaces)\n    slug = slug.replace(/[^a-z0-9\\s-]/gi, ' ');\n\n    // 4. Replace multiple spaces or hyphens with a single hyphen\n    slug = slug.replace(/[\\s-]+/g, '-');\n\n    // 5. Remove leading/trailing hyphens\n    slug = slug.replace(/^-+|-+$/g, '');\n\n    return slug;\n}\n\n/**\n * Generates a slug from a string or an object containing strings.\n * The slug is a URL-friendly version of the string, removing special characters\n * and converting spaces to hyphens. This function can handle both single strings\n * and objects with string values.\n *\n * @param input - The string or object to be slugified.\n * @param options - Options for slugification including replacement character, case sensitivity, locale, etc.\n * @returns The slugified string or object with the same structure as the input.\n */\nexport function generateSlug<T = string>(\n    input: T,\n    options?: I_SlugifyOptions,\n): T {\n    const slugifyWithOptions = (value: string) =>\n        slugify(value ?? '', options);\n\n    if (typeof input === 'object' && input !== null) {\n        const result: T_Object = {};\n\n        for (const [key, value] of Object.entries(input)) {\n            result[key] = slugifyWithOptions(value as string);\n        }\n\n        return result as T;\n    }\n\n    return slugifyWithOptions(input as string) as T;\n}\n\n/**\n * Generates a short ID from a UUID.\n * The ID is a substring of the UUID, providing a shorter identifier.\n * Note: This is NOT cryptographically secure and collisions are possible,\n * but suitable for display purposes where uniqueness is handled elsewhere.\n *\n * @param uuid - The UUID to be converted to a short ID.\n * @param length - The desired length of the short ID (default: 4 characters).\n * @returns A short ID string of the specified length derived from the UUID.\n */\nexport function generateShortId(uuid: string, length = 4): string {\n    // Simple hash function (FNV-1a variant) to generate a hex string from the UUID\n    let hash = 0x811C9DC5;\n    for (let i = 0; i < uuid.length; i++) {\n        hash ^= uuid.charCodeAt(i);\n        hash = Math.imul(hash, 0x01000193);\n    }\n    // Convert to unsigned 32-bit integer hex string\n    const hex = (hash >>> 0).toString(16).padStart(8, '0');\n\n    // If we need more than 8 chars, we can just append part of the original UUID (stripped of dashes)\n    // or use a different strategy. For short IDs (usually < 8), the hash is fine.\n    // If length > 8, we fallback to just slicing the clean UUID.\n    if (length > 8) {\n        return uuid.replace(/-/g, '').slice(0, length);\n    }\n\n    return hex.slice(0, length);\n}\n\n/**\n * Internal helper that fills `length` characters from `charset` using\n * rejection-sampling over `crypto.getRandomValues` to avoid modulo bias.\n * Random values are requested in bounded chunks to keep allocations small.\n *\n * @param length - Number of characters to generate.\n * @param charset - The pool of characters to draw from.\n * @returns A randomly generated string of the requested length.\n */\nfunction generateRandomFromCharset(length: number, charset: string): string {\n    const limit = Math.floor(2 ** 32 / charset.length) * charset.length;\n    const result: string[] = [];\n    const MAX_UINT32_VALUES_PER_CALL = 16384;\n\n    while (result.length < length) {\n        const remaining = length - result.length;\n        const chunkSize = remaining > MAX_UINT32_VALUES_PER_CALL ? MAX_UINT32_VALUES_PER_CALL : remaining;\n        const values = new Uint32Array(chunkSize);\n        crypto.getRandomValues(values);\n\n        for (const value of values) {\n            if (result.length >= length) {\n                break;\n            }\n            if (value < limit) {\n                result.push(charset[value % charset.length] as string);\n            }\n        }\n    }\n\n    return result.join('');\n}\n\n/**\n * Generates a random password of a given length.\n * The password contains a mix of letters (both cases), numbers, and special characters\n * to ensure complexity and security.\n *\n * @param length - The desired length of the password (default: 8 characters).\n * @returns A randomly generated password string with the specified length.\n * @throws {RangeError} If `length` is not a non-negative safe integer.\n */\nexport function generateRandomPassword(length = 8): string {\n    if (!Number.isSafeInteger(length) || length < 0) {\n        throw new RangeError('length must be a non-negative safe integer');\n    }\n\n    const charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+[]{}|;:,.<>?';\n\n    return generateRandomFromCharset(length, charset);\n}\n\n/**\n * Generates a random string of a given length using a secure random number generator.\n * This function is a cryptographically secure alternative to Math.random().toString(36).\n *\n * @param length - The desired length of the string (default: 8 characters).\n * @param charset - The characters to use (default: lowercase alphanumeric).\n * @returns A randomly generated string.\n * @throws {RangeError} If `length` is not a non-negative safe integer.\n * @throws {RangeError} If `charset` is empty or exceeds 2^32 characters.\n */\nexport function generateRandomString(\n    length = 8,\n    charset = 'abcdefghijklmnopqrstuvwxyz0123456789',\n): string {\n    if (!Number.isSafeInteger(length) || length < 0) {\n        throw new RangeError('length must be a non-negative safe integer');\n    }\n\n    if (charset.length === 0 || charset.length > 2 ** 32) {\n        throw new RangeError('charset.length must be between 1 and 2^32');\n    }\n\n    return generateRandomFromCharset(length, charset);\n}\n\n/**\n * Get the file name from a URL.\n * This function extracts the file name from a URL, optionally including or excluding\n * the file extension. It handles URLs with query parameters and fragments.\n *\n * @param url - The URL to extract the file name from (default: empty string).\n * @param getExtension - Whether to include the file extension in the result (default: false).\n * @returns The file name extracted from the URL, with or without the extension.\n */\nexport function getFileName(url = '', getExtension = false): string {\n    const withoutQuery = url.split(/[?#]/)[0] || '';\n    const fileName = withoutQuery.substring(withoutQuery.lastIndexOf('/') + 1);\n\n    if (getExtension) {\n        return fileName;\n    }\n\n    const dotIndex = fileName.lastIndexOf('.');\n\n    return dotIndex > 0 ? fileName.slice(0, dotIndex) : fileName;\n}\n\n/**\n * Extracts a substring between two strings.\n * This function finds the first occurrence of the starting string, then finds the first\n * occurrence of the ending string after the starting string, and returns the content between them.\n *\n * @param s - The original string to search within.\n * @param a - The starting string that marks the beginning of the desired substring.\n * @param b - The ending string that marks the end of the desired substring.\n * @returns The substring between the two specified strings, or an empty string if either string is not found.\n */\nexport function substringBetween(s: string, a: string, b: string): string {\n    const start = s.indexOf(a);\n\n    if (start === -1) {\n        return '';\n    }\n\n    const from = start + a.length;\n    const end = s.indexOf(b, from);\n\n    if (end === -1) {\n        return '';\n    }\n\n    return s.slice(from, end);\n}\n"],"names":["removeAccent","slugify","input","options","slug","generateSlug","slugifyWithOptions","value","result","key","generateShortId","uuid","length","hash","i","hex","generateRandomFromCharset","charset","limit","MAX_UINT32_VALUES_PER_CALL","remaining","chunkSize","values","generateRandomPassword","generateRandomString","getFileName","url","getExtension","withoutQuery","fileName","dotIndex","substringBetween","s","a","b","start","from","end"],"mappings":"AAeA,SAAA,gBAAAA,SAAA;AAAA,SAASC,EAAQC,GAAeC,GAAoC;AAChE,MAAIC,IAAOF,EAAM,KAAA;AAGjB,SAAAE,IAAOJ,EAAaI,CAAI,GAGpBD,GAAS,UAAU,OACnBC,IAAOA,EAAK,YAAA,IAIhBA,IAAOA,EAAK,QAAQ,kBAAkB,GAAG,GAGzCA,IAAOA,EAAK,QAAQ,WAAW,GAAG,GAGlCA,IAAOA,EAAK,QAAQ,YAAY,EAAE,GAE3BA;AACX;AAYO,SAASC,EACZH,GACAC,GACC;AACD,QAAMG,IAAqB,CAACC,MACxBN,EAAQM,KAAS,IAAIJ,CAAO;AAEhC,MAAI,OAAOD,KAAU,YAAYA,MAAU,MAAM;AAC7C,UAAMM,IAAmB,CAAA;AAEzB,eAAW,CAACC,GAAKF,CAAK,KAAK,OAAO,QAAQL,CAAK;AAC3C,MAAAM,EAAOC,CAAG,IAAIH,EAAmBC,CAAe;AAGpD,WAAOC;AAAA,EACX;AAEA,SAAOF,EAAmBJ,CAAe;AAC7C;AAYO,SAASQ,EAAgBC,GAAcC,IAAS,GAAW;AAE9D,MAAIC,IAAO;AACX,WAASC,IAAI,GAAGA,IAAIH,EAAK,QAAQG;AAC7B,IAAAD,KAAQF,EAAK,WAAWG,CAAC,GACzBD,IAAO,KAAK,KAAKA,GAAM,QAAU;AAGrC,QAAME,KAAOF,MAAS,GAAG,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAKrD,SAAID,IAAS,IACFD,EAAK,QAAQ,MAAM,EAAE,EAAE,MAAM,GAAGC,CAAM,IAG1CG,EAAI,MAAM,GAAGH,CAAM;AAC9B;AAWA,SAASI,EAA0BJ,GAAgBK,GAAyB;AACxE,QAAMC,IAAQ,KAAK,MAAM,aAAUD,EAAQ,MAAM,IAAIA,EAAQ,QACvDT,IAAmB,CAAA,GACnBW,IAA6B;AAEnC,SAAOX,EAAO,SAASI,KAAQ;AAC3B,UAAMQ,IAAYR,IAASJ,EAAO,QAC5Ba,IAAYD,IAAYD,IAA6BA,IAA6BC,GAClFE,IAAS,IAAI,YAAYD,CAAS;AACxC,WAAO,gBAAgBC,CAAM;AAE7B,eAAWf,KAASe,GAAQ;AACxB,UAAId,EAAO,UAAUI;AACjB;AAEJ,MAAIL,IAAQW,KACRV,EAAO,KAAKS,EAAQV,IAAQU,EAAQ,MAAM,CAAW;AAAA,IAE7D;AAAA,EACJ;AAEA,SAAOT,EAAO,KAAK,EAAE;AACzB;AAWO,SAASe,EAAuBX,IAAS,GAAW;AACvD,MAAI,CAAC,OAAO,cAAcA,CAAM,KAAKA,IAAS;AAC1C,UAAM,IAAI,WAAW,4CAA4C;AAKrE,SAAOI,EAA0BJ,GAFjB,wFAEgC;AACpD;AAYO,SAASY,EACZZ,IAAS,GACTK,IAAU,wCACJ;AACN,MAAI,CAAC,OAAO,cAAcL,CAAM,KAAKA,IAAS;AAC1C,UAAM,IAAI,WAAW,4CAA4C;AAGrE,MAAIK,EAAQ,WAAW,KAAKA,EAAQ,SAAS,KAAK;AAC9C,UAAM,IAAI,WAAW,2CAA2C;AAGpE,SAAOD,EAA0BJ,GAAQK,CAAO;AACpD;AAWO,SAASQ,EAAYC,IAAM,IAAIC,IAAe,IAAe;AAChE,QAAMC,IAAeF,EAAI,MAAM,MAAM,EAAE,CAAC,KAAK,IACvCG,IAAWD,EAAa,UAAUA,EAAa,YAAY,GAAG,IAAI,CAAC;AAEzE,MAAID;AACA,WAAOE;AAGX,QAAMC,IAAWD,EAAS,YAAY,GAAG;AAEzC,SAAOC,IAAW,IAAID,EAAS,MAAM,GAAGC,CAAQ,IAAID;AACxD;AAYO,SAASE,EAAiBC,GAAWC,GAAWC,GAAmB;AACtE,QAAMC,IAAQH,EAAE,QAAQC,CAAC;AAEzB,MAAIE,MAAU;AACV,WAAO;AAGX,QAAMC,IAAOD,IAAQF,EAAE,QACjBI,IAAML,EAAE,QAAQE,GAAGE,CAAI;AAE7B,SAAIC,MAAQ,KACD,KAGJL,EAAE,MAAMI,GAAMC,CAAG;AAC5B;"}

package/dist/util/validate/index.js

@@ -2,3 +2,4 @@ import { validate as o } from "./validate.util.js";
 export {
   o as validate
 };
+//# sourceMappingURL=index.js.map

package/dist/util/validate/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/util/validate/validate.util.js

@@ -37,3 +37,4 @@ const e = {
 export {
   e as validate
 };
+//# sourceMappingURL=validate.util.js.map

package/dist/util/validate/validate.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.util.js","sources":["../../../src/util/validate/validate.util.ts"],"sourcesContent":["/**\n * A collection of validation utility functions for common data validation tasks.\n * This object provides methods to validate various data types and formats.\n */\nexport const validate = {\n    /**\n     * Checks if a value is empty.\n     * This function provides comprehensive empty checking for different data types:\n     * - For strings, it checks if the string is empty or contains only whitespace.\n     * - For arrays, it checks if the array has no elements.\n     * - For objects, it checks if the object has no own properties.\n     * - For Maps and Sets, it checks if they are empty.\n     * - For WeakMaps and WeakSets, it returns true (as they are not enumerable).\n     * - For ArrayBuffer views, it checks if the byte length is 0.\n     * - For Dates, it returns false.\n     * - For null and undefined, it returns true.\n     * - For all other types, it returns false.\n     *\n     * @param value - The value to check for emptiness.\n     * @returns True if the value is empty, false otherwise.\n     */\n    isEmpty(value: unknown): boolean {\n        if (value === null || value === undefined) {\n            return true;\n        }\n\n        if (typeof value === 'string') {\n            return value.trim().length === 0;\n        }\n\n        if (Array.isArray(value)) {\n            return value.length === 0;\n        }\n\n        if (typeof value === 'object') {\n            if (value instanceof Date) {\n                return false;\n            }\n\n            if (value instanceof Map || value instanceof Set) {\n                return value.size === 0;\n            }\n\n            if (value instanceof WeakMap || value instanceof WeakSet) {\n                return true;\n            }\n\n            if (ArrayBuffer.isView(value)) {\n                return value.byteLength === 0;\n            }\n\n            return Object.keys(value).length === 0;\n        }\n\n        return false;\n    },\n    /**\n     * Checks if a string is a valid IP address (IPv4 or IPv6).\n     * This function validates IP addresses according to standard formats:\n     * - IPv4: Four octets separated by dots, each between 0–255.\n     * - IPv6: Eight groups of four hex digits, possibly compressed with `::`.\n     *\n     * @param ip - The IP address string to validate.\n     * @returns True if the IP is valid IPv4 or IPv6, false otherwise.\n     */\n    isValidIP(ip: string): boolean {\n        const ipv4Parts = ip.split('.');\n\n        if (ipv4Parts.length === 4 && ipv4Parts.every(octet =>\n            /^\\d+$/.test(octet)\n            && Number(octet) >= 0\n            && Number(octet) <= 255,\n        )) {\n            return true;\n        }\n\n        const ipv6Regex = /^(?:(?:[a-f\\d]{1,4}:){7}(?:[a-f\\d]{1,4}|:)|(?:[a-f\\d]{1,4}:){6}(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|:[a-f\\d]{1,4}|:)|(?:[a-f\\d]{1,4}:){5}(?::(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-f\\d]{1,4}){1,2}|:)|(?:[a-f\\d]{1,4}:){4}(?:(?::[a-f\\d]{1,4})?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-f\\d]{1,4}){1,3}|:)|(?:[a-f\\d]{1,4}:){3}(?:(?::[a-f\\d]{1,4}){0,2}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-f\\d]{1,4}){1,4}|:)|(?:[a-f\\d]{1,4}:){2}(?:(?::[a-f\\d]{1,4}){0,3}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-f\\d]{1,4}){1,5}|:)|[a-f\\d]{1,4}:(?:(?::[a-f\\d]{1,4}){0,4}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-f\\d]{1,4}){1,6}|:)|:(?:(?::[a-f\\d]{1,4}){0,5}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-f\\d]{1,4}){1,7}|:))(?:%[0-9a-z]+)?$/i;\n\n        return ipv6Regex.test(ip);\n    },\n};\n"],"names":["validate","value","ip","ipv4Parts","octet"],"mappings":"AAIO,MAAMA,IAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBpB,QAAQC,GAAyB;AAC7B,WAAIA,KAAU,OACH,KAGP,OAAOA,KAAU,WACVA,EAAM,OAAO,WAAW,IAG/B,MAAM,QAAQA,CAAK,IACZA,EAAM,WAAW,IAGxB,OAAOA,KAAU,WACbA,aAAiB,OACV,KAGPA,aAAiB,OAAOA,aAAiB,MAClCA,EAAM,SAAS,IAGtBA,aAAiB,WAAWA,aAAiB,UACtC,KAGP,YAAY,OAAOA,CAAK,IACjBA,EAAM,eAAe,IAGzB,OAAO,KAAKA,CAAK,EAAE,WAAW,IAGlC;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,UAAUC,GAAqB;AAC3B,UAAMC,IAAYD,EAAG,MAAM,GAAG;AAE9B,WAAIC,EAAU,WAAW,KAAKA,EAAU;AAAA,MAAM,CAAAC,MAC1C,QAAQ,KAAKA,CAAK,KACf,OAAOA,CAAK,KAAK,KACjB,OAAOA,CAAK,KAAK;AAAA,IAAA,IAEb,KAGO,+iCAED,KAAKF,CAAE;AAAA,EAC5B;AACJ;"}