@zinaid/utils 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Abraham Arango
+
+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.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,46 @@
+import { castableToArray as s, compareValues as t, entriesKeyValue as r, getAccessibleValues as a, isAccessibleData as o, isArray as l, isBoolean as b, isFalsy as n, isFiniteNumber as u, isFloat as c, isFunction as y, isInteger as m, isMap as p, isNegativeNumber as A, isNonPrimitive as N, isNull as S, isNumber as g, isObject as F, isObjectAny as v, isPositiveNumber as T, isPrimitive as f, isSet as j, isString as O, isStringable as P, isSymbol as V, isTruthy as d, isTruthyObject as h, isUndefined as k, isWeakMap as q, isWeakSet as w, looseEqual as z, lowerFirst as D, normalizeToArray as E, objectToString as J, resolveDefault as M, strictEqual as U, toArrayable as W, toJsonSerializable as x, toJsonable as B, toLower as I, toUpper as K, typeOf as L, upperFirst as C } from "./utils.js";
+export {
+  s as castableToArray,
+  t as compareValues,
+  r as entriesKeyValue,
+  a as getAccessibleValues,
+  o as isAccessibleData,
+  l as isArray,
+  b as isBoolean,
+  n as isFalsy,
+  u as isFiniteNumber,
+  c as isFloat,
+  y as isFunction,
+  m as isInteger,
+  p as isMap,
+  A as isNegativeNumber,
+  N as isNonPrimitive,
+  S as isNull,
+  g as isNumber,
+  F as isObject,
+  v as isObjectAny,
+  T as isPositiveNumber,
+  f as isPrimitive,
+  j as isSet,
+  O as isString,
+  P as isStringable,
+  V as isSymbol,
+  d as isTruthy,
+  h as isTruthyObject,
+  k as isUndefined,
+  q as isWeakMap,
+  w as isWeakSet,
+  z as looseEqual,
+  D as lowerFirst,
+  E as normalizeToArray,
+  J as objectToString,
+  M as resolveDefault,
+  U as strictEqual,
+  W as toArrayable,
+  x as toJsonSerializable,
+  B as toJsonable,
+  I as toLower,
+  K as toUpper,
+  L as typeOf,
+  C as upperFirst
+};

package/dist/utils.d.ts

@@ -0,0 +1,514 @@
+import { DataItems } from '../../types/src/index.ts';
+/**
+ * Check if a value is an array.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an array
+ */
+export declare function isArray<T>(value: DataItems<T> | T[] | unknown): value is T[];
+/**
+ * Check if a value is an object (not null, not array).
+ *
+ * @param value - The value to check
+ * @returns True if the value is an object
+ *
+ * @example
+ *
+ * isObject({a: 1, b: 2}); -> true
+ * isObject([1, 2, 3]); -> false
+ * isObject(null); -> false
+ */
+export declare function isObject<T, K extends PropertyKey = PropertyKey>(value: DataItems<T, K> | unknown): value is Record<K, T>;
+/**
+ * Check if a value is any object (including arrays, null).
+ *
+ * @param value - The value to check
+ * @returns True if the value is any object
+ *
+ * @example
+ *
+ * isObjectAny({a: 1, b: 2}); -> true
+ * isObjectAny([1, 2, 3]); -> true
+ * isObjectAny(null); -> true
+ */
+export declare function isObjectAny(value: unknown): value is object;
+/**
+ * Check if a value is a truthy object (not null, not undefined, and an object).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a truthy object
+ *
+ * @example
+ *
+ * isTruthyObject({a: 1, b: 2}); -> true
+ * isTruthyObject([1, 2, 3]); -> true
+ * isTruthyObject(null); -> false
+ * isTruthyObject(undefined); -> false
+ */
+export declare function isTruthyObject(value: unknown): value is object;
+/**
+ * Check if a value is a string.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a string
+ *
+ * @example
+ *
+ * isString("hello"); -> true
+ * isString(123); -> false
+ * isString(null); -> false
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Convert a string to lower-case.
+ */
+export declare function toLower(value: string): string;
+/**
+ * Convert a string to upper-case.
+ */
+export declare function toUpper(value: string): string;
+/**
+ * Convert the first character of a string to lower-case.
+ */
+export declare function lowerFirst(value: string): string;
+/**
+ * Convert the first character of a string to upper-case.
+ */
+export declare function upperFirst(value: string): string;
+/**
+ * Check if a value is stringable (can be converted to a string).
+ *
+ * @param value - The value to check
+ * @returns True if the value is stringable
+ *
+ * @example
+ *
+ * isStringable("hello"); -> true
+ * isStringable(new Stringable('test')); -> true
+ * isStringable({ toString: () => "world" }); -> true
+ * isStringable(123); -> false
+ * isStringable(null); -> false
+ */
+export declare function isStringable(value: unknown): value is string | {
+    toString(): string;
+};
+/**
+ * Check if a value is an object with a toString method.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an object with a toString method
+ */
+export declare function objectToString(value: unknown): value is {
+    toString(): string;
+};
+/**
+ * Check if a value is a number (and not NaN).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid number
+ *
+ * @example
+ *
+ * isNumber(123); -> true
+ * isNumber(3.14); -> true
+ * isNumber(NaN); -> false
+ * isNumber("123"); -> false
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Check if a value is an integer.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an integer
+ */
+export declare function isInteger(value: unknown): value is number;
+/**
+ * Check if a value is a float.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a float
+ */
+export declare function isFloat(value: unknown): value is number;
+/**
+ * Check if a value is a positive number.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a positive number
+ */
+export declare function isPositiveNumber(value: unknown): value is number;
+/**
+ * Check if a value is a negative number.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a negative number
+ */
+export declare function isNegativeNumber(value: unknown): value is number;
+/**
+ * Check if a value is a boolean.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a boolean
+ *
+ * @example
+ *
+ * isBoolean(true); -> true
+ * isBoolean(false); -> true
+ * isBoolean(0); -> false
+ * isBoolean("true"); -> false
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Check if a value is a function.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a function
+ *
+ * @example
+ *
+ * isFunction(() => {}); -> true
+ * isFunction(Math.max); -> true
+ * isFunction("function"); -> false
+ * isFunction({}); -> false
+ */
+export declare function isFunction<T extends (...args: unknown[]) => unknown>(value: unknown): value is T;
+/**
+ * Check if a value is undefined.
+ *
+ * @param value - The value to check
+ * @returns True if the value is undefined
+ *
+ * @example
+ *
+ * isUndefined(undefined); -> true
+ * isUndefined(null); -> false
+ * isUndefined(""); -> false
+ * isUndefined(0); -> false
+ */
+export declare function isUndefined(value: unknown): value is undefined;
+/**
+ * Check if a value is a symbol.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a symbol
+ *
+ * @example
+ *
+ * isSymbol(Symbol('test')); -> true
+ * isSymbol(Symbol.iterator); -> true
+ * isSymbol("symbol"); -> false
+ * isSymbol({}); -> false
+ */
+export declare function isSymbol(value: unknown): value is symbol;
+/**
+ * Check if a value is null.
+ *
+ * @param value - The value to check
+ * @returns True if the value is null
+ *
+ * @example
+ *
+ * isNull(null); -> true
+ * isNull(undefined); -> false
+ * isNull(""); -> false
+ * isNull(0); -> false
+ */
+export declare function isNull(value: unknown): value is null;
+/**
+ * Check if a value is a Map.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Map
+ *
+ * @example
+ *
+ * isMap(new Map()); -> true
+ * isMap({}); -> false
+ * isMap([]); -> false
+ */
+export declare function isMap<K, V>(value: unknown): value is Map<K, V>;
+/**
+ * Check if a value is a Set.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Set
+ *
+ * @example
+ *
+ * isSet(new Set()); -> true
+ * isSet({}); -> false
+ * isSet([]); -> false
+ */
+export declare function isSet<T>(value: unknown): value is Set<T>;
+/**
+ * Check if a value is a WeakMap.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a WeakMap
+ */
+export declare function isWeakMap<K extends object, V>(value: unknown): value is WeakMap<K, V>;
+/**
+ * Check if a value is a WeakSet.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a WeakSet
+ */
+export declare function isWeakSet<T extends object>(value: unknown): value is WeakSet<T>;
+/**
+ * Check if a value is arrayable (has a toArray method).
+ *
+ * @param value - The value to check
+ * @returns True if the value is arrayable
+ *
+ * @example
+ *
+ * isArrayable({ toArray: () => [1, 2, 3] }); -> true
+ * isArrayable([1, 2, 3]); -> false
+ * isArrayable("hello"); -> false
+ */
+export declare function toArrayable<T>(value: unknown): value is {
+    toArray(): T[];
+};
+/**
+ * Check if a value is jsonable (has a toJSON method).
+ *
+ * @param value - The value to check
+ * @returns True if the value is jsonable
+ *
+ * @example
+ *
+ * isJsonable({ toJSON: () => ({ a: 1 }) }); -> true
+ * isJsonable("hello"); -> false
+ */
+export declare function toJsonable<T>(value: unknown): value is {
+    toJson(): T;
+} | {
+    toJSON(): T;
+};
+/**
+ * Check if a value is json serializable (has a jsonSerialize method).
+ *
+ * @param value - The value to check
+ * @returns True if the value is json serializable
+ *
+ * @example
+ *
+ * isJsonSerializable({ jsonSerialize: () => ({ a: 1 }) }); -> true
+ * isJsonSerializable("hello"); -> false
+ */
+export declare function toJsonSerializable<T>(value: unknown): value is {
+    jsonSerialize(): T;
+};
+/**
+ * Check if a value is falsy (undefined, null, false, 0, "", empty array/object).
+ *
+ * @param value - The value to check
+ * @returns True if the value is falsy
+ *
+ * @example
+ *
+ * isFalsy(undefined); -> true
+ * isFalsy(null); -> true
+ * isFalsy(false); -> true
+ * isFalsy(0); -> true
+ * isFalsy(""); -> true
+ * isFalsy([]); -> true
+ * isFalsy({}); -> true
+ * isFalsy("hello"); -> false
+ * isFalsy([1, 2, 3]); -> false
+ * isFalsy({ a: 1 }); -> false
+ */
+export declare function isFalsy<TValue = unknown>(value: TValue): boolean;
+/**
+ * Check if a value is truthy (not falsy).
+ *
+ * @param value - The value to check
+ * @returns True if the value is truthy
+ *
+ * @example
+ *
+ * isTruthy(1); -> true
+ * isTruthy("hello"); -> true
+ * isTruthy([1, 2, 3]); -> true
+ * isTruthy({ a: 1 }); -> true
+ * isTruthy(0); -> false
+ * isTruthy(""); -> false
+ * isTruthy([]); -> false
+ * isTruthy({}); -> false
+ */
+export declare function isTruthy(value: unknown): boolean;
+/**
+ * Get a more specific type description for debugging purposes.
+ * Differentiates between null, arrays, and other types.
+ *
+ * @param {unknown} v - The value to get the type of.
+ * @returns {string} A string describing the type.
+ * @example
+ * Get specific types
+ * typeOf(null); -> "null"
+ * typeOf([]); -> "array"
+ * typeOf({}); -> "object"
+ */
+export declare function typeOf(v: unknown): string;
+/**
+ * Check if a value is a primitive type (null, boolean, number, string, symbol, undefined).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a primitive
+ *
+ * @example
+ *
+ * isPrimitive(123); -> true
+ * isPrimitive("hello"); -> true
+ * isPrimitive(null); -> true
+ * isPrimitive({}); -> false
+ * isPrimitive([]); -> false
+ */
+export declare function isPrimitive(value: unknown): boolean;
+/**
+ * Check if a value is a non-primitive type (object, array, function, etc.).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a non-primitive
+ *
+ * @example
+ *
+ * isNonPrimitive({}); -> true
+ * isNonPrimitive([]); -> true
+ * isNonPrimitive(() => {}); -> true
+ * isNonPrimitive(123); -> false
+ * isNonPrimitive("hello"); -> false
+ */
+export declare function isNonPrimitive(value: unknown): boolean;
+/**
+ * Check if a value is a finite number.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a finite number
+ *
+ * @example
+ *
+ * isFiniteNumber(123); -> true
+ * isFiniteNumber(3.14); -> true
+ * isFiniteNumber(Infinity); -> false
+ * isFiniteNumber(NaN); -> false
+ * isFiniteNumber("123"); -> false
+ */
+export declare function isFiniteNumber(value: unknown): value is number;
+/**
+ * Convert a value to an array if it's already an array, otherwise return null.
+ * Used internally for safe array conversion without coercion.
+ *
+ * @param {unknown} value - The value to convert.
+ * @returns {unknown[] | null} The array if value is an array, null otherwise.
+ * @example
+ * Convert to array
+ * toArray([1, 2, 3]); -> [1, 2, 3]
+ * toArray("hello"); -> null
+ * toArray({}); -> null
+ */
+export declare function castableToArray<T>(value: unknown): T[] | null;
+/**
+ * Helper function to safely compare two unknown values for sorting.
+ * Provides stable comparison for objects using JSON serialization.
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @returns -1 if a < b, 1 if a > b, 0 if equal
+ *
+ * @example
+ * compareValues(1, 2); -> -1
+ * compareValues('b', 'a'); -> 1
+ * compareValues({x: 1}, {x: 1}); -> 0
+ */
+export declare function compareValues(a: unknown, b: unknown): number;
+/**
+ * Helper function to resolve a default value (either direct value or lazy function).
+ *
+ * @param defaultValue - The default value or lazy function
+ * @returns The resolved default value
+ *
+ * @example
+ * resolveDefault('hello'); -> 'hello'
+ * resolveDefault(() => 'world'); -> 'world'
+ * resolveDefault(undefined); -> null
+ */
+export declare function resolveDefault<D>(defaultValue?: D | (() => D)): D | null;
+/**
+ * Helper function to normalize data to an array format.
+ * Handles arrays only now.
+ *
+ * @param data - The data to normalize (array or other)
+ * @returns An array representation of the data, or null if not accessible
+ *
+ * @example
+ * normalizeToArray([1, 2, 3]); -> [1, 2, 3]
+ * normalizeToArray('hello'); -> null
+ */
+export declare function normalizeToArray<T>(data: ReadonlyArray<T> | unknown): T[] | null;
+/**
+ * Helper function to check if data is accessible (array only).
+ *
+ * @param data - The data to check
+ * @returns True if data is an array
+ *
+ * @example
+ * isAccessibleData([1, 2, 3]); -> true
+ * isAccessibleData('hello'); -> false
+ */
+export declare function isAccessibleData(data: unknown): boolean;
+/**
+ * Helper function to get normalized values from data.
+ * Returns array values or empty array if data is not accessible.
+ *
+ * @param data - The data to get values from
+ * @returns Array of values or empty array
+ *
+ * @example
+ * getAccessibleValues([1, 2, 3]); -> [1, 2, 3]
+ * getAccessibleValues('hello'); -> []
+ */
+export declare function getAccessibleValues<T>(data: ReadonlyArray<T> | unknown): T[];
+/**
+ * PHP-like loose equality comparison.
+ * Mimics PHP's == operator behavior where null, false, 0, '', and [] are considered loosely equal.
+ * Also handles deep comparison for arrays and objects.
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @returns True if values are loosely equal in PHP-like manner
+ *
+ * @example
+ *
+ * looseEqual(null, false); -> true
+ * looseEqual(null, 0); -> true
+ * looseEqual(null, ''); -> true
+ * looseEqual(0, false); -> true
+ * looseEqual(1, '1'); -> true
+ * looseEqual(['a'], ['a']); -> true
+ */
+export declare function looseEqual(a: unknown, b: unknown): boolean;
+/**
+ * PHP-like strict equality comparison (=== operator).
+ * Performs strict type checking for primitives but value-based comparison for arrays and objects.
+ * NOTE: For class instances (objects with constructors other than Object), uses reference equality.
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @returns True if values are strictly equal in PHP-like manner
+ *
+ * @example
+ *
+ * strictEqual(1, 1); -> true
+ * strictEqual(1, '1'); -> false (different types)
+ * strictEqual(['a'], ['a']); -> true (same array content)
+ * strictEqual({a: 1}, {a: 1}); -> true (same object content)
+ */
+export declare function strictEqual(a: unknown, b: unknown): boolean;
+/**
+ * Figures out if the entry key should be a number or a string.
+ *
+ * @param value - The entry key value (number, string, or symbol)
+ * @returns The entry key as a number if it can be converted, otherwise returns the original value
+ */
+export declare function entriesKeyValue<T extends PropertyKey>(value: T): T extends `${number}` ? number : T;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}

package/dist/utils.js

@@ -0,0 +1,240 @@
+function l(r) {
+  return Array.isArray(r);
+}
+function y(r) {
+  return !f(r) && typeof r == "object" && !l(r);
+}
+function h(r) {
+  return typeof r == "object";
+}
+function J(r) {
+  return !f(r) && !p(r) && h(r);
+}
+function A(r) {
+  return typeof r == "string";
+}
+function d(r) {
+  return r.toLowerCase();
+}
+function z(r) {
+  return r.toUpperCase();
+}
+function T(r) {
+  const t = [...r];
+  return t.length === 0 ? r : (t[0] = t[0].toLowerCase(), t.join(""));
+}
+function B(r) {
+  const t = [...r];
+  return t.length === 0 ? r : (t[0] = t[0].toUpperCase(), t.join(""));
+}
+function P(r) {
+  return !!(A(r) || o(r) || j(r));
+}
+function j(r) {
+  return !!(y(r) && c(r.toString));
+}
+function o(r) {
+  return typeof r == "number" && !isNaN(r);
+}
+function w(r) {
+  return o(r) && Number.isInteger(r);
+}
+function C(r) {
+  return o(r) && !Number.isInteger(r);
+}
+function M(r) {
+  return o(r) && r >= 0;
+}
+function U(r) {
+  return o(r) && r < 0;
+}
+function N(r) {
+  return typeof r == "boolean";
+}
+function c(r) {
+  return typeof r == "function";
+}
+function p(r) {
+  return typeof r > "u";
+}
+function m(r) {
+  return typeof r == "symbol";
+}
+function f(r) {
+  return r === null;
+}
+function S(r) {
+  return r instanceof Map;
+}
+function b(r) {
+  return r instanceof Set;
+}
+function W(r) {
+  return r instanceof WeakMap;
+}
+function I(r) {
+  return r instanceof WeakSet;
+}
+function L(r) {
+  return y(r) && !f(r) && c(r.toArray);
+}
+function q(r) {
+  if (!y(r) || f(r))
+    return !1;
+  const t = c(r.toJson), e = c(r.toJSON);
+  return t || e;
+}
+function D(r) {
+  return y(r) && !f(r) && c(r.jsonSerialize);
+}
+function k(r) {
+  return Number.isNaN(r) ? !0 : o(r) ? r === 0 : p(r) || f(r) ? !0 : N(r) ? r === !1 : A(r) ? r.trim() === "" : S(r) || b(r) ? r.size === 0 : l(r) ? r.length === 0 : y(r) ? Object.keys(r).length === 0 : !1;
+}
+function E(r) {
+  return !k(r);
+}
+function V(r) {
+  return f(r) ? "object" : l(r) ? "array" : typeof r;
+}
+function O(r) {
+  return f(r) || N(r) || o(r) || A(r) || m(r) || p(r);
+}
+function x(r) {
+  return !O(r);
+}
+function K(r) {
+  return o(r) && Number.isFinite(r);
+}
+function G(r) {
+  return l(r) ? r : null;
+}
+function H(r, t) {
+  if (r == null && t == null) return 0;
+  if (r == null) return -1;
+  if (t == null) return 1;
+  if (typeof r == "object" && typeof t == "object") {
+    const e = JSON.stringify(r), u = JSON.stringify(t);
+    return e < u ? -1 : e > u ? 1 : 0;
+  }
+  return r < t ? -1 : r > t ? 1 : 0;
+}
+function Q(r) {
+  return r === void 0 ? null : typeof r == "function" ? r() : r;
+}
+function F(r) {
+  return Array.isArray(r) ? r.slice() : null;
+}
+function R(r) {
+  return Array.isArray(r);
+}
+function X(r) {
+  return F(r) || [];
+}
+function g(r, t) {
+  if (r == t)
+    return !0;
+  if (typeof r == "boolean" || typeof t == "boolean") {
+    const i = typeof r == "boolean" ? r : t, n = typeof r == "boolean" ? t : r;
+    return i === !0 ? !(n === null || n === !1 || n === 0 || n === "" || Array.isArray(n) && n.length === 0) : n === null || n === 0 || n === "";
+  }
+  const e = r === null || r === !1 || r === 0 || r === "" || Array.isArray(r) && r.length === 0, u = t === null || t === !1 || t === 0 || t === "" || Array.isArray(t) && t.length === 0;
+  if (e && u)
+    return !0;
+  if (Array.isArray(r) && Array.isArray(t)) {
+    if (r.length !== t.length)
+      return !1;
+    for (let i = 0; i < r.length; i++)
+      if (!g(r[i], t[i]))
+        return !1;
+    return !0;
+  }
+  if (r !== null && t !== null && typeof r == "object" && typeof t == "object" && !Array.isArray(r) && !Array.isArray(t)) {
+    const i = Object.keys(r), n = Object.keys(t);
+    if (i.length !== n.length)
+      return !1;
+    for (const s of i)
+      if (!n.includes(s) || !g(
+        r[s],
+        t[s]
+      ))
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+function a(r, t) {
+  if (r === t)
+    return !0;
+  if (Array.isArray(r) && Array.isArray(t)) {
+    if (r.length !== t.length)
+      return !1;
+    for (let e = 0; e < r.length; e++)
+      if (!a(r[e], t[e]))
+        return !1;
+    return !0;
+  }
+  if (r !== null && t !== null && typeof r == "object" && typeof t == "object" && !Array.isArray(r) && !Array.isArray(t)) {
+    const e = r.constructor === Object || r.constructor === void 0, u = t.constructor === Object || t.constructor === void 0;
+    if (!e || !u)
+      return !1;
+    const i = Object.keys(r), n = Object.keys(t);
+    if (i.length !== n.length)
+      return !1;
+    for (const s of i)
+      if (!n.includes(s) || !a(
+        r[s],
+        t[s]
+      ))
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+function Y(r) {
+  return !isNaN(Number(r)) && !isNaN(parseFloat(String(r))) ? Number(r) : r;
+}
+export {
+  G as castableToArray,
+  H as compareValues,
+  Y as entriesKeyValue,
+  X as getAccessibleValues,
+  R as isAccessibleData,
+  l as isArray,
+  N as isBoolean,
+  k as isFalsy,
+  K as isFiniteNumber,
+  C as isFloat,
+  c as isFunction,
+  w as isInteger,
+  S as isMap,
+  U as isNegativeNumber,
+  x as isNonPrimitive,
+  f as isNull,
+  o as isNumber,
+  y as isObject,
+  h as isObjectAny,
+  M as isPositiveNumber,
+  O as isPrimitive,
+  b as isSet,
+  A as isString,
+  P as isStringable,
+  m as isSymbol,
+  E as isTruthy,
+  J as isTruthyObject,
+  p as isUndefined,
+  W as isWeakMap,
+  I as isWeakSet,
+  g as looseEqual,
+  T as lowerFirst,
+  F as normalizeToArray,
+  j as objectToString,
+  Q as resolveDefault,
+  a as strictEqual,
+  L as toArrayable,
+  D as toJsonSerializable,
+  q as toJsonable,
+  d as toLower,
+  z as toUpper,
+  V as typeOf,
+  B as upperFirst
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@zinaid/utils",
+  "version": "0.0.1",
+  "description": "A set of utility functions for the @zinaid packages.",
+  "type": "module",
+  "main": "dist/index.js",
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "vite build"
+  },
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "require": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  }
+}