@vielzeug/toolkit 1.1.2 → 2.0.0

package/dist/typed/is.d.ts

@@ -0,0 +1,95 @@
+import { isArray } from './isArray';
+import { isBoolean } from './isBoolean';
+import { isDate } from './isDate';
+import { isDefined } from './isDefined';
+import { isEmpty } from './isEmpty';
+import { isEqual } from './isEqual';
+import { isEven } from './isEven';
+import { isFunction } from './isFunction';
+import { isMatch } from './isMatch';
+import { isNegative } from './isNegative';
+import { isNil } from './isNil';
+import { isNumber } from './isNumber';
+import { isObject } from './isObject';
+import { isOdd } from './isOdd';
+import { isPositive } from './isPositive';
+import { isPrimitive } from './isPrimitive';
+import { isPromise } from './isPromise';
+import { isRegex } from './isRegex';
+import { isString } from './isString';
+import { isWithin } from './isWithin';
+import { isZero } from './isZero';
+import { typeOf } from './typeOf';
+/**
+ * Namespace of type-checking and comparison utilities.
+ *
+ * @example
+ * ```ts
+ * is.string('hello');          // true
+ * is.array([1, 2, 3]);         // true
+ * is.nil(null);                // true
+ * is.nil(undefined);           // true
+ * is.equal([1, 2], [1, 2]);    // true
+ * is.positive(5);              // true
+ * is.within(3, 1, 5);          // true
+ * is.match({ a: 1, b: 2 }, { a: 1 }); // true
+ * is.ge(5, 5);                 // true
+ * is.gt(5, 3);                 // true
+ * is.typeOf('hello');          // 'string'
+ * ```
+ */
+export declare const is: {
+    /** `true` if value is an array */
+    array: typeof isArray;
+    /** `true` if value is a boolean */
+    boolean: typeof isBoolean;
+    /** `true` if value is a valid Date */
+    date: typeof isDate;
+    /** `true` if value is not `undefined` */
+    defined: typeof isDefined;
+    /** `true` if value is null, undefined, `''`, `[]`, or `{}` */
+    empty: typeof isEmpty;
+    /** Deep equality check */
+    equal: typeof isEqual;
+    /** `true` if value is an even integer */
+    even: typeof isEven;
+    /** `true` if value is a function */
+    fn: typeof isFunction;
+    /** `true` if a >= b (numbers only) */
+    ge: (a: number, b: number) => boolean;
+    /** `true` if a > b (numbers only) */
+    gt: (a: number, b: number) => boolean;
+    /** `true` if a <= b (numbers only) */
+    le: (a: number, b: number) => boolean;
+    /** `true` if a < b (numbers only) */
+    lt: (a: number, b: number) => boolean;
+    /** Partial deep-match: `true` if `object` contains all of `source`'s properties */
+    match: typeof isMatch;
+    /** `true` if value is a negative number */
+    negative: typeof isNegative;
+    /** `true` if value is null or undefined */
+    nil: typeof isNil;
+    /** `true` if value is a number (excluding NaN) */
+    number: typeof isNumber;
+    /** `true` if value is a plain object */
+    object: typeof isObject;
+    /** `true` if value is an odd integer */
+    odd: typeof isOdd;
+    /** `true` if value is a positive number */
+    positive: typeof isPositive;
+    /** `true` if value is a string, number, or boolean */
+    primitive: typeof isPrimitive;
+    /** `true` if value is a Promise */
+    promise: typeof isPromise;
+    /** `true` if value is a RegExp */
+    regex: typeof isRegex;
+    /** `true` if value is a string */
+    string: typeof isString;
+    /** Returns the runtime type tag of the value */
+    typeOf: typeof typeOf;
+    /** `true` if value is within [min, max] (inclusive) */
+    within: typeof isWithin;
+    /** `true` if value is exactly 0 */
+    zero: typeof isZero;
+};
+//# sourceMappingURL=is.d.ts.map

package/dist/typed/is.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is.d.ts","sourceRoot":"","sources":["../../src/typed/is.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,EAAE;IACb,kCAAkC;;IAElC,mCAAmC;;IAEnC,sCAAsC;;IAEtC,yCAAyC;;IAEzC,8DAA8D;;IAE9D,0BAA0B;;IAE1B,yCAAyC;;IAEzC,oCAAoC;;IAEpC,sCAAsC;YAC9B,MAAM,KAAK,MAAM;IACzB,qCAAqC;YAC7B,MAAM,KAAK,MAAM;IACzB,sCAAsC;YAC9B,MAAM,KAAK,MAAM;IACzB,qCAAqC;YAC7B,MAAM,KAAK,MAAM;IACzB,mFAAmF;;IAEnF,2CAA2C;;IAE3C,2CAA2C;;IAE3C,kDAAkD;;IAElD,wCAAwC;;IAExC,wCAAwC;;IAExC,2CAA2C;;IAE3C,sDAAsD;;IAEtD,mCAAmC;;IAEnC,kCAAkC;;IAElC,kCAAkC;;IAElC,gDAAgD;;IAEhD,uDAAuD;;IAEvD,mCAAmC;;CAEpC,CAAC"}

package/dist/typed/is.js

@@ -1,43 +1,55 @@
-import { assert as t } from "../function/assert.js";
-import { ge as e } from "./ge.js";
-import { gt as p } from "./gt.js";
-import { isDefined as f } from "./isDefined.js";
-import { isEmpty as s } from "./isEmpty.js";
-import { isEqual as m } from "./isEqual.js";
-import { isEven as n } from "./isEven.js";
-import { isMatch as a } from "./isMatch.js";
-import { isNegative as d } from "./isNegative.js";
-import { isNil as g } from "./isNil.js";
-import { isOdd as l } from "./isOdd.js";
-import { isPositive as v } from "./isPositive.js";
-import { isRegex as c } from "./isRegex.js";
-import { isWithin as h } from "./isWithin.js";
-import { isZero as u } from "./isZero.js";
-import { le as E } from "./le.js";
-import { lt as x } from "./lt.js";
-import { typeOf as q } from "./typeOf.js";
-function G(r, i) {
-  return t(!!r, "Type must be provided", { args: { type: r }, type: Error }), {
-    defined: f,
-    empty: s,
-    eq: (o) => m(...o),
-    even: n,
-    ge: (o) => e(...o),
-    gt: (o) => p(...o),
-    le: (o) => E(...o),
-    lt: (o) => x(...o),
-    match: (o) => a(...o),
-    ne: (o) => !m(...o),
-    negative: d,
-    nil: g,
-    odd: l,
-    positive: v,
-    regex: c,
-    within: (o) => h(...o),
-    zero: u
-  }[r]?.(i) ?? q(i) === r;
-}
-export {
-  G as is
+import { isArray as e } from "./isArray.js";
+import { isString as t } from "./isString.js";
+import { isEqual as n } from "./isEqual.js";
+import { isNil as r } from "./isNil.js";
+import { isNumber as i } from "./isNumber.js";
+import { isObject as a } from "./isObject.js";
+import { isWithin as o } from "./isWithin.js";
+import { isDate as s } from "./isDate.js";
+import { isEmpty as c } from "./isEmpty.js";
+import { isBoolean as l } from "./isBoolean.js";
+import { isDefined as u } from "./isDefined.js";
+import { isEven as d } from "./isEven.js";
+import { isFunction as f } from "./isFunction.js";
+import { isMatch as p } from "./isMatch.js";
+import { isNegative as m } from "./isNegative.js";
+import { isOdd as h } from "./isOdd.js";
+import { isPositive as g } from "./isPositive.js";
+import { isPrimitive as _ } from "./isPrimitive.js";
+import { isPromise as v } from "./isPromise.js";
+import { isRegex as y } from "./isRegex.js";
+import { isZero as b } from "./isZero.js";
+import { typeOf as x } from "./typeOf.js";
+//#region src/typed/is.ts
+var S = {
+	array: e,
+	boolean: l,
+	date: s,
+	defined: u,
+	empty: c,
+	equal: n,
+	even: d,
+	fn: f,
+	ge: (e, t) => e >= t,
+	gt: (e, t) => e > t,
+	le: (e, t) => e <= t,
+	lt: (e, t) => e < t,
+	match: p,
+	negative: m,
+	nil: r,
+	number: i,
+	object: a,
+	odd: h,
+	positive: g,
+	primitive: _,
+	promise: v,
+	regex: y,
+	string: t,
+	typeOf: x,
+	within: o,
+	zero: b
 };
-//# sourceMappingURL=is.js.map
+//#endregion
+export { S as is };
+
+//# sourceMappingURL=is.js.map

package/dist/typed/is.js.map

@@ -1 +1 @@
-{"version":3,"file":"is.js","sources":["../../src/typed/is.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { ge } from './ge';\nimport { gt } from './gt';\nimport { isDefined } from './isDefined';\nimport { isEmpty } from './isEmpty';\nimport { isEqual } from './isEqual';\nimport { isEven } from './isEven';\nimport { isMatch } from './isMatch';\nimport { isNegative } from './isNegative';\nimport { isNil } from './isNil';\nimport { isOdd } from './isOdd';\nimport { isPositive } from './isPositive';\nimport { isRegex } from './isRegex';\nimport { isWithin } from './isWithin';\nimport { isZero } from './isZero';\nimport { le } from './le';\nimport { lt } from './lt';\nimport { type ArgType, typeOf } from './typeOf';\n\ntype isType =\n  | ArgType\n  | 'defined'\n  | 'empty'\n  | 'eq'\n  | 'even'\n  | 'ge'\n  | 'gt'\n  | 'le'\n  | 'lt'\n  | 'match'\n  | 'ne'\n  | 'negative'\n  | 'nil'\n  | 'odd'\n  | 'positive'\n  | 'regex'\n  | 'within'\n  | 'zero';\n\n/**\n * @description\n * Checks if the value type of argument.\n *\n * @example\n * ```ts\n * is('array', []);\n * is('boolean', true);\n * is('date', new Date());\n * is('defined', 123);\n * is('empty', []);\n * is('even', 2);\n * is('function', () => {});\n * is('match', { a: 1, b: 2 }, { a: 1 });\n * is('nan', Number.NaN);\n * is('negative', -123);\n * is('nil', null);\n * is('null', null);\n * is('number', 123);\n * is('object', {});\n * is('odd', 3);\n * is('positive', 123);\n * is('string', 'hello');\n * is('symbol', Symbol('test'));\n * is('regex', /abc/);\n * is('string', 'hello world');\n * is('undefined', undefined);\n * is('within', 1, 2, 3);\n * is('zero', 0);\n * is('eq', [1, 2, 3], [1, 2, 3]);\n * is('ne', [1, 2, 3], [1, 2]);\n * is('ge', 5, 5);\n * is('gt', 5, 3);\n * is('le', 5, 5);\n * is('lt', 3, 5);\n * ```\n *\n * @param type - The type to check against.\n * @param args - The argument to be checked.\n *\n * @returns `true` if the value is of the specified type, else `false`.\n */\nexport function is(type: 'within', ...args: Parameters<typeof isWithin>): boolean;\nexport function is(type: 'eq', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'ne', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'gt', ...args: Parameters<typeof gt>): boolean;\nexport function is(type: 'ge', ...args: Parameters<typeof ge>): boolean;\nexport function is(type: 'lt', ...args: Parameters<typeof lt>): boolean;\nexport function is(type: 'le', ...args: Parameters<typeof le>): boolean;\nexport function is(type: 'match', ...args: Parameters<typeof isMatch>): boolean;\nexport function is(type: 'empty', ...args: Parameters<typeof isEmpty>): boolean;\nexport function is(type: 'array', arg: unknown): arg is Array<unknown>;\nexport function is(type: 'string', arg: unknown): arg is string;\nexport function is(type: 'number', arg: unknown): arg is number;\nexport function is(type: 'object', arg: unknown): arg is object;\nexport function is(type: 'nil', arg: unknown): arg is null | undefined;\nexport function is(type: 'primitive', arg: unknown): arg is string | number | boolean;\nexport function is(type: isType, arg: unknown): boolean;\nexport function is(type: string, arg: unknown): boolean {\n  assert(Boolean(type), 'Type must be provided', { args: { type }, type: Error });\n\n  const compare = {\n    defined: isDefined,\n    empty: isEmpty,\n    eq: (args: Parameters<typeof isEqual>) => isEqual(...args),\n    even: isEven,\n    ge: (args: Parameters<typeof ge>) => ge(...args),\n    gt: (args: Parameters<typeof gt>) => gt(...args),\n    le: (args: Parameters<typeof le>) => le(...args),\n    lt: (args: Parameters<typeof lt>) => lt(...args),\n    match: (args: Parameters<typeof isMatch>) => isMatch(...args),\n    ne: (args: Parameters<typeof isEqual>) => !isEqual(...args),\n    negative: isNegative,\n    nil: isNil,\n    odd: isOdd,\n    positive: isPositive,\n    regex: isRegex,\n    within: (args: Parameters<typeof isWithin>) => isWithin(...args),\n    zero: isZero,\n  };\n\n  return compare[type as keyof typeof compare]?.(arg) ?? typeOf(arg) === type;\n}\n"],"names":["is","type","arg","assert","isDefined","isEmpty","args","isEqual","isEven","ge","gt","le","lt","isMatch","isNegative","isNil","isOdd","isPositive","isRegex","isWithin","isZero","typeOf"],"mappings":";;;;;;;;;;;;;;;;;;AAiGO,SAASA,EAAGC,GAAcC,GAAuB;AACtD,SAAAC,EAAO,EAAQF,GAAO,yBAAyB,EAAE,MAAM,EAAE,MAAAA,EAAA,GAAQ,MAAM,OAAO,GAE9D;AAAA,IACd,SAASG;AAAA,IACT,OAAOC;AAAA,IACP,IAAI,CAACC,MAAqCC,EAAQ,GAAGD,CAAI;AAAA,IACzD,MAAME;AAAA,IACN,IAAI,CAACF,MAAgCG,EAAG,GAAGH,CAAI;AAAA,IAC/C,IAAI,CAACA,MAAgCI,EAAG,GAAGJ,CAAI;AAAA,IAC/C,IAAI,CAACA,MAAgCK,EAAG,GAAGL,CAAI;AAAA,IAC/C,IAAI,CAACA,MAAgCM,EAAG,GAAGN,CAAI;AAAA,IAC/C,OAAO,CAACA,MAAqCO,EAAQ,GAAGP,CAAI;AAAA,IAC5D,IAAI,CAACA,MAAqC,CAACC,EAAQ,GAAGD,CAAI;AAAA,IAC1D,UAAUQ;AAAA,IACV,KAAKC;AAAA,IACL,KAAKC;AAAA,IACL,UAAUC;AAAA,IACV,OAAOC;AAAA,IACP,QAAQ,CAACZ,MAAsCa,EAAS,GAAGb,CAAI;AAAA,IAC/D,MAAMc;AAAA,EAAA,EAGOnB,CAA4B,IAAIC,CAAG,KAAKmB,EAAOnB,CAAG,MAAMD;AACzE;"}
+{"version":3,"file":"is.js","names":[],"sources":["../../src/typed/is.ts"],"sourcesContent":["import { isArray } from './isArray';\nimport { isBoolean } from './isBoolean';\nimport { isDate } from './isDate';\nimport { isDefined } from './isDefined';\nimport { isEmpty } from './isEmpty';\nimport { isEqual } from './isEqual';\nimport { isEven } from './isEven';\nimport { isFunction } from './isFunction';\nimport { isMatch } from './isMatch';\nimport { isNegative } from './isNegative';\nimport { isNil } from './isNil';\nimport { isNumber } from './isNumber';\nimport { isObject } from './isObject';\nimport { isOdd } from './isOdd';\nimport { isPositive } from './isPositive';\nimport { isPrimitive } from './isPrimitive';\nimport { isPromise } from './isPromise';\nimport { isRegex } from './isRegex';\nimport { isString } from './isString';\nimport { isWithin } from './isWithin';\nimport { isZero } from './isZero';\nimport { typeOf } from './typeOf';\n\n/**\n * Namespace of type-checking and comparison utilities.\n *\n * @example\n * ```ts\n * is.string('hello');          // true\n * is.array([1, 2, 3]);         // true\n * is.nil(null);                // true\n * is.nil(undefined);           // true\n * is.equal([1, 2], [1, 2]);    // true\n * is.positive(5);              // true\n * is.within(3, 1, 5);          // true\n * is.match({ a: 1, b: 2 }, { a: 1 }); // true\n * is.ge(5, 5);                 // true\n * is.gt(5, 3);                 // true\n * is.typeOf('hello');          // 'string'\n * ```\n */\nexport const is = {\n  /** `true` if value is an array */\n  array: isArray,\n  /** `true` if value is a boolean */\n  boolean: isBoolean,\n  /** `true` if value is a valid Date */\n  date: isDate,\n  /** `true` if value is not `undefined` */\n  defined: isDefined,\n  /** `true` if value is null, undefined, `''`, `[]`, or `{}` */\n  empty: isEmpty,\n  /** Deep equality check */\n  equal: isEqual,\n  /** `true` if value is an even integer */\n  even: isEven,\n  /** `true` if value is a function */\n  fn: isFunction,\n  /** `true` if a >= b (numbers only) */\n  ge: (a: number, b: number) => a >= b,\n  /** `true` if a > b (numbers only) */\n  gt: (a: number, b: number) => a > b,\n  /** `true` if a <= b (numbers only) */\n  le: (a: number, b: number) => a <= b,\n  /** `true` if a < b (numbers only) */\n  lt: (a: number, b: number) => a < b,\n  /** Partial deep-match: `true` if `object` contains all of `source`'s properties */\n  match: isMatch,\n  /** `true` if value is a negative number */\n  negative: isNegative,\n  /** `true` if value is null or undefined */\n  nil: isNil,\n  /** `true` if value is a number (excluding NaN) */\n  number: isNumber,\n  /** `true` if value is a plain object */\n  object: isObject,\n  /** `true` if value is an odd integer */\n  odd: isOdd,\n  /** `true` if value is a positive number */\n  positive: isPositive,\n  /** `true` if value is a string, number, or boolean */\n  primitive: isPrimitive,\n  /** `true` if value is a Promise */\n  promise: isPromise,\n  /** `true` if value is a RegExp */\n  regex: isRegex,\n  /** `true` if value is a string */\n  string: isString,\n  /** Returns the runtime type tag of the value */\n  typeOf,\n  /** `true` if value is within [min, max] (inclusive) */\n  within: isWithin,\n  /** `true` if value is exactly 0 */\n  zero: isZero,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,IAAK;CAEhB,OAAO;CAEP,SAAS;CAET,MAAM;CAEN,SAAS;CAET,OAAO;CAEP,OAAO;CAEP,MAAM;CAEN,IAAI;CAEJ,KAAK,GAAW,MAAc,KAAK;CAEnC,KAAK,GAAW,MAAc,IAAI;CAElC,KAAK,GAAW,MAAc,KAAK;CAEnC,KAAK,GAAW,MAAc,IAAI;CAElC,OAAO;CAEP,UAAU;CAEV,KAAK;CAEL,QAAQ;CAER,QAAQ;CAER,KAAK;CAEL,UAAU;CAEV,WAAW;CAEX,SAAS;CAET,OAAO;CAEP,QAAQ;CAER;CAEA,QAAQ;CAER,MAAM;CACP"}

package/dist/typed/isArray.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function e(r){return Array.isArray(r)}const t="Expected an array";exports.IS_ARRAY_ERROR_MSG=t;exports.isArray=e;
-//# sourceMappingURL=isArray.cjs.map
+function e(e){return Array.isArray(e)}var t=`Expected an array`;exports.IS_ARRAY_ERROR_MSG=t,exports.isArray=e;
+//# sourceMappingURL=isArray.cjs.map

package/dist/typed/isArray.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"isArray.cjs","sources":["../../src/typed/isArray.ts"],"sourcesContent":["/**\n * Determines if the passed value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]) // true\n * isArray(1, 2, 3) // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is an array, else `false`.\n */\nexport function isArray(arg: unknown): arg is Array<unknown> {\n  return Array.isArray(arg);\n}\n\nexport const IS_ARRAY_ERROR_MSG = 'Expected an array';\n"],"names":["isArray","arg","IS_ARRAY_ERROR_MSG"],"mappings":"gFAaO,SAASA,EAAQC,EAAqC,CAC3D,OAAO,MAAM,QAAQA,CAAG,CAC1B,CAEO,MAAMC,EAAqB"}
+{"version":3,"file":"isArray.cjs","names":[],"sources":["../../src/typed/isArray.ts"],"sourcesContent":["/**\n * Determines if the passed value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]) // true\n * isArray(1, 2, 3) // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is an array, else `false`.\n */\nexport function isArray(arg: unknown): arg is Array<unknown> {\n  return Array.isArray(arg);\n}\n\nexport const IS_ARRAY_ERROR_MSG = 'Expected an array';\n"],"mappings":"AAaA,SAAgB,EAAQ,EAAqC,CAC3D,OAAO,MAAM,QAAQ,EAAI,CAG3B,IAAa,EAAqB"}

package/dist/typed/isArray.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Determines if the passed value is an array.
+ *
+ * @example
+ * ```ts
+ * isArray([1, 2, 3]) // true
+ * isArray(1, 2, 3) // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is an array, else `false`.
+ */
+export declare function isArray(arg: unknown): arg is Array<unknown>;
+export declare const IS_ARRAY_ERROR_MSG = "Expected an array";
+//# sourceMappingURL=isArray.d.ts.map

package/dist/typed/isArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isArray.d.ts","sourceRoot":"","sources":["../../src/typed/isArray.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAE3D;AAED,eAAO,MAAM,kBAAkB,sBAAsB,CAAC"}

package/dist/typed/isArray.js

@@ -1,9 +1,9 @@
-function a(r) {
-  return Array.isArray(r);
+//#region src/typed/isArray.ts
+function e(e) {
+	return Array.isArray(e);
 }
-const n = "Expected an array";
-export {
-  n as IS_ARRAY_ERROR_MSG,
-  a as isArray
-};
-//# sourceMappingURL=isArray.js.map
+var t = "Expected an array";
+//#endregion
+export { t as IS_ARRAY_ERROR_MSG, e as isArray };
+
+//# sourceMappingURL=isArray.js.map

package/dist/typed/isArray.js.map

@@ -1 +1 @@
-{"version":3,"file":"isArray.js","sources":["../../src/typed/isArray.ts"],"sourcesContent":["/**\n * Determines if the passed value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]) // true\n * isArray(1, 2, 3) // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is an array, else `false`.\n */\nexport function isArray(arg: unknown): arg is Array<unknown> {\n  return Array.isArray(arg);\n}\n\nexport const IS_ARRAY_ERROR_MSG = 'Expected an array';\n"],"names":["isArray","arg","IS_ARRAY_ERROR_MSG"],"mappings":"AAaO,SAASA,EAAQC,GAAqC;AAC3D,SAAO,MAAM,QAAQA,CAAG;AAC1B;AAEO,MAAMC,IAAqB;"}
+{"version":3,"file":"isArray.js","names":[],"sources":["../../src/typed/isArray.ts"],"sourcesContent":["/**\n * Determines if the passed value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]) // true\n * isArray(1, 2, 3) // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is an array, else `false`.\n */\nexport function isArray(arg: unknown): arg is Array<unknown> {\n  return Array.isArray(arg);\n}\n\nexport const IS_ARRAY_ERROR_MSG = 'Expected an array';\n"],"mappings":";AAaA,SAAgB,EAAQ,GAAqC;AAC3D,QAAO,MAAM,QAAQ,EAAI;;AAG3B,IAAa,IAAqB"}

package/dist/typed/isBoolean.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function o(e){return typeof e=="boolean"}exports.isBoolean=o;
-//# sourceMappingURL=isBoolean.cjs.map
+function e(e){return typeof e==`boolean`}exports.isBoolean=e;
+//# sourceMappingURL=isBoolean.cjs.map

package/dist/typed/isBoolean.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"isBoolean.cjs","sources":["../../src/typed/isBoolean.ts"],"sourcesContent":["/**\n * Checks if the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * isBoolean(false); // true\n * isBoolean(123); // false\n * isBoolean('hello world'); // false\n * isBoolean({}); // false\n * isBoolean([]); // false\n * isBoolean(new Date()); // false\n * isBoolean(null); // false\n * isBoolean(undefined); // false\n * isBoolean(NaN); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a boolean, else `false`.\n */\nexport function isBoolean(arg: unknown): arg is boolean {\n  return typeof arg === 'boolean';\n}\n"],"names":["isBoolean","arg"],"mappings":"gFAqBO,SAASA,EAAUC,EAA8B,CACtD,OAAO,OAAOA,GAAQ,SACxB"}
+{"version":3,"file":"isBoolean.cjs","names":[],"sources":["../../src/typed/isBoolean.ts"],"sourcesContent":["/**\n * Checks if the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * isBoolean(false); // true\n * isBoolean(123); // false\n * isBoolean('hello world'); // false\n * isBoolean({}); // false\n * isBoolean([]); // false\n * isBoolean(new Date()); // false\n * isBoolean(null); // false\n * isBoolean(undefined); // false\n * isBoolean(NaN); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a boolean, else `false`.\n */\nexport function isBoolean(arg: unknown): arg is boolean {\n  return typeof arg === 'boolean';\n}\n"],"mappings":"AAqBA,SAAgB,EAAU,EAA8B,CACtD,OAAO,OAAO,GAAQ"}

package/dist/typed/isBoolean.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Checks if the value is a boolean.
+ *
+ * @example
+ * ```ts
+ * isBoolean(true); // true
+ * isBoolean(false); // true
+ * isBoolean(123); // false
+ * isBoolean('hello world'); // false
+ * isBoolean({}); // false
+ * isBoolean([]); // false
+ * isBoolean(new Date()); // false
+ * isBoolean(null); // false
+ * isBoolean(undefined); // false
+ * isBoolean(NaN); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a boolean, else `false`.
+ */
+export declare function isBoolean(arg: unknown): arg is boolean;
+//# sourceMappingURL=isBoolean.d.ts.map

package/dist/typed/isBoolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBoolean.d.ts","sourceRoot":"","sources":["../../src/typed/isBoolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,OAAO,CAEtD"}

package/dist/typed/isBoolean.js

@@ -1,7 +1,8 @@
-function e(o) {
-  return typeof o == "boolean";
+//#region src/typed/isBoolean.ts
+function e(e) {
+	return typeof e == "boolean";
 }
-export {
-  e as isBoolean
-};
-//# sourceMappingURL=isBoolean.js.map
+//#endregion
+export { e as isBoolean };
+
+//# sourceMappingURL=isBoolean.js.map

package/dist/typed/isBoolean.js.map

@@ -1 +1 @@
-{"version":3,"file":"isBoolean.js","sources":["../../src/typed/isBoolean.ts"],"sourcesContent":["/**\n * Checks if the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * isBoolean(false); // true\n * isBoolean(123); // false\n * isBoolean('hello world'); // false\n * isBoolean({}); // false\n * isBoolean([]); // false\n * isBoolean(new Date()); // false\n * isBoolean(null); // false\n * isBoolean(undefined); // false\n * isBoolean(NaN); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a boolean, else `false`.\n */\nexport function isBoolean(arg: unknown): arg is boolean {\n  return typeof arg === 'boolean';\n}\n"],"names":["isBoolean","arg"],"mappings":"AAqBO,SAASA,EAAUC,GAA8B;AACtD,SAAO,OAAOA,KAAQ;AACxB;"}
+{"version":3,"file":"isBoolean.js","names":[],"sources":["../../src/typed/isBoolean.ts"],"sourcesContent":["/**\n * Checks if the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * isBoolean(false); // true\n * isBoolean(123); // false\n * isBoolean('hello world'); // false\n * isBoolean({}); // false\n * isBoolean([]); // false\n * isBoolean(new Date()); // false\n * isBoolean(null); // false\n * isBoolean(undefined); // false\n * isBoolean(NaN); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a boolean, else `false`.\n */\nexport function isBoolean(arg: unknown): arg is boolean {\n  return typeof arg === 'boolean';\n}\n"],"mappings":";AAqBA,SAAgB,EAAU,GAA8B;AACtD,QAAO,OAAO,KAAQ"}

package/dist/typed/isDate.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function t(e){return e instanceof Date&&!Number.isNaN(e.getTime())}const i="Expected a Date object";exports.IS_DATE_ERROR_MSG=i;exports.isDate=t;
-//# sourceMappingURL=isDate.cjs.map
+function e(e){return e instanceof Date&&!Number.isNaN(e.getTime())}exports.isDate=e;
+//# sourceMappingURL=isDate.cjs.map

package/dist/typed/isDate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"isDate.cjs","sources":["../../src/typed/isDate.ts"],"sourcesContent":["/**\n * Determines if the passed value is a valid Date Object.\n *\n * @example\n * ```ts\n * isDate(new Date()); // true\n * isDate(123); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a valid Date object, else `false`.\n */\nexport function isDate(arg: unknown): arg is Date {\n  return arg instanceof Date && !Number.isNaN(arg.getTime());\n}\n\nexport const IS_DATE_ERROR_MSG = 'Expected a Date object';\n"],"names":["isDate","arg","IS_DATE_ERROR_MSG"],"mappings":"gFAaO,SAASA,EAAOC,EAA2B,CAChD,OAAOA,aAAe,MAAQ,CAAC,OAAO,MAAMA,EAAI,SAAS,CAC3D,CAEO,MAAMC,EAAoB"}
+{"version":3,"file":"isDate.cjs","names":[],"sources":["../../src/typed/isDate.ts"],"sourcesContent":["/**\n * Determines if the passed value is a valid Date Object.\n *\n * @example\n * ```ts\n * isDate(new Date()); // true\n * isDate(123); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a valid Date object, else `false`.\n */\nexport function isDate(arg: unknown): arg is Date {\n  return arg instanceof Date && !Number.isNaN(arg.getTime());\n}\n\nexport const IS_DATE_ERROR_MSG = 'Expected a Date object';\n"],"mappings":"AAaA,SAAgB,EAAO,EAA2B,CAChD,OAAO,aAAe,MAAQ,CAAC,OAAO,MAAM,EAAI,SAAS,CAAC"}

package/dist/typed/isDate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Determines if the passed value is a valid Date Object.
+ *
+ * @example
+ * ```ts
+ * isDate(new Date()); // true
+ * isDate(123); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a valid Date object, else `false`.
+ */
+export declare function isDate(arg: unknown): arg is Date;
+export declare const IS_DATE_ERROR_MSG = "Expected a Date object";
+//# sourceMappingURL=isDate.d.ts.map

package/dist/typed/isDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDate.d.ts","sourceRoot":"","sources":["../../src/typed/isDate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,IAAI,CAEhD;AAED,eAAO,MAAM,iBAAiB,2BAA2B,CAAC"}

package/dist/typed/isDate.js

@@ -1,9 +1,8 @@
-function t(e) {
-  return e instanceof Date && !Number.isNaN(e.getTime());
+//#region src/typed/isDate.ts
+function e(e) {
+	return e instanceof Date && !Number.isNaN(e.getTime());
 }
-const n = "Expected a Date object";
-export {
-  n as IS_DATE_ERROR_MSG,
-  t as isDate
-};
-//# sourceMappingURL=isDate.js.map
+//#endregion
+export { e as isDate };
+
+//# sourceMappingURL=isDate.js.map

package/dist/typed/isDate.js.map

@@ -1 +1 @@
-{"version":3,"file":"isDate.js","sources":["../../src/typed/isDate.ts"],"sourcesContent":["/**\n * Determines if the passed value is a valid Date Object.\n *\n * @example\n * ```ts\n * isDate(new Date()); // true\n * isDate(123); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a valid Date object, else `false`.\n */\nexport function isDate(arg: unknown): arg is Date {\n  return arg instanceof Date && !Number.isNaN(arg.getTime());\n}\n\nexport const IS_DATE_ERROR_MSG = 'Expected a Date object';\n"],"names":["isDate","arg","IS_DATE_ERROR_MSG"],"mappings":"AAaO,SAASA,EAAOC,GAA2B;AAChD,SAAOA,aAAe,QAAQ,CAAC,OAAO,MAAMA,EAAI,SAAS;AAC3D;AAEO,MAAMC,IAAoB;"}
+{"version":3,"file":"isDate.js","names":[],"sources":["../../src/typed/isDate.ts"],"sourcesContent":["/**\n * Determines if the passed value is a valid Date Object.\n *\n * @example\n * ```ts\n * isDate(new Date()); // true\n * isDate(123); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a valid Date object, else `false`.\n */\nexport function isDate(arg: unknown): arg is Date {\n  return arg instanceof Date && !Number.isNaN(arg.getTime());\n}\n\nexport const IS_DATE_ERROR_MSG = 'Expected a Date object';\n"],"mappings":";AAaA,SAAgB,EAAO,GAA2B;AAChD,QAAO,aAAe,QAAQ,CAAC,OAAO,MAAM,EAAI,SAAS,CAAC"}

package/dist/typed/isDefined.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function i(e){return e!==void 0}exports.isDefined=i;
-//# sourceMappingURL=isDefined.cjs.map
+function e(e){return e!==void 0}exports.isDefined=e;
+//# sourceMappingURL=isDefined.cjs.map

package/dist/typed/isDefined.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"isDefined.cjs","sources":["../../src/typed/isDefined.ts"],"sourcesContent":["/**\n * Checks if a value is defined (not `undefined`).\n *\n * @example\n * ```ts\n * isDefined(123); // true\n * isDefined(undefined); // false\n * isDefined('hello world'); // true\n * isDefined({}); // true\n * isDefined([]); // true\n * isDefined(null); // true\n * ```\n *\n * @param arg - The value to check.\n *\n * @returns `true` if the value is defined, else `false`.\n */\nexport function isDefined<T>(arg: T | undefined): arg is T {\n  return arg !== undefined;\n}\n"],"names":["isDefined","arg"],"mappings":"gFAiBO,SAASA,EAAaC,EAA8B,CACzD,OAAOA,IAAQ,MACjB"}
+{"version":3,"file":"isDefined.cjs","names":[],"sources":["../../src/typed/isDefined.ts"],"sourcesContent":["/**\n * Checks if a value is defined (not `undefined`).\n *\n * @example\n * ```ts\n * isDefined(123); // true\n * isDefined(undefined); // false\n * isDefined('hello world'); // true\n * isDefined({}); // true\n * isDefined([]); // true\n * isDefined(null); // true\n * ```\n *\n * @param arg - The value to check.\n *\n * @returns `true` if the value is defined, else `false`.\n */\nexport function isDefined<T>(arg: T | undefined): arg is T {\n  return arg !== undefined;\n}\n"],"mappings":"AAiBA,SAAgB,EAAa,EAA8B,CACzD,OAAO,IAAQ,IAAA"}

package/dist/typed/isDefined.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Checks if a value is defined (not `undefined`).
+ *
+ * @example
+ * ```ts
+ * isDefined(123); // true
+ * isDefined(undefined); // false
+ * isDefined('hello world'); // true
+ * isDefined({}); // true
+ * isDefined([]); // true
+ * isDefined(null); // true
+ * ```
+ *
+ * @param arg - The value to check.
+ *
+ * @returns `true` if the value is defined, else `false`.
+ */
+export declare function isDefined<T>(arg: T | undefined): arg is T;
+//# sourceMappingURL=isDefined.d.ts.map

package/dist/typed/isDefined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDefined.d.ts","sourceRoot":"","sources":["../../src/typed/isDefined.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,GAAG,GAAG,IAAI,CAAC,CAEzD"}

package/dist/typed/isDefined.js

@@ -1,7 +1,8 @@
-function i(e) {
-  return e !== void 0;
+//#region src/typed/isDefined.ts
+function e(e) {
+	return e !== void 0;
 }
-export {
-  i as isDefined
-};
-//# sourceMappingURL=isDefined.js.map
+//#endregion
+export { e as isDefined };
+
+//# sourceMappingURL=isDefined.js.map

package/dist/typed/isDefined.js.map

@@ -1 +1 @@
-{"version":3,"file":"isDefined.js","sources":["../../src/typed/isDefined.ts"],"sourcesContent":["/**\n * Checks if a value is defined (not `undefined`).\n *\n * @example\n * ```ts\n * isDefined(123); // true\n * isDefined(undefined); // false\n * isDefined('hello world'); // true\n * isDefined({}); // true\n * isDefined([]); // true\n * isDefined(null); // true\n * ```\n *\n * @param arg - The value to check.\n *\n * @returns `true` if the value is defined, else `false`.\n */\nexport function isDefined<T>(arg: T | undefined): arg is T {\n  return arg !== undefined;\n}\n"],"names":["isDefined","arg"],"mappings":"AAiBO,SAASA,EAAaC,GAA8B;AACzD,SAAOA,MAAQ;AACjB;"}
+{"version":3,"file":"isDefined.js","names":[],"sources":["../../src/typed/isDefined.ts"],"sourcesContent":["/**\n * Checks if a value is defined (not `undefined`).\n *\n * @example\n * ```ts\n * isDefined(123); // true\n * isDefined(undefined); // false\n * isDefined('hello world'); // true\n * isDefined({}); // true\n * isDefined([]); // true\n * isDefined(null); // true\n * ```\n *\n * @param arg - The value to check.\n *\n * @returns `true` if the value is defined, else `false`.\n */\nexport function isDefined<T>(arg: T | undefined): arg is T {\n  return arg !== undefined;\n}\n"],"mappings":";AAiBA,SAAgB,EAAa,GAA8B;AACzD,QAAO,MAAQ,KAAA"}

package/dist/typed/isEmpty.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./isArray.cjs"),i=require("./isNil.cjs"),n=require("./isObject.cjs");function s(e){return i.isNil(e)||e===""?!0:t.isArray(e)?e.length===0:e instanceof Map||e instanceof Set?e.size===0:n.isObject(e)?Object.keys(e).length===0:!1}const r="Expected an empty value";exports.IS_EMPTY_ERROR_MSG=r;exports.isEmpty=s;
-//# sourceMappingURL=isEmpty.cjs.map
+const e=require(`./isArray.cjs`),t=require(`./isNil.cjs`),n=require(`./isObject.cjs`);function r(r){return t.isNil(r)||r===``?!0:e.isArray(r)?r.length===0:r instanceof Map||r instanceof Set?r.size===0:n.isObject(r)?Object.keys(r).length===0:!1}exports.isEmpty=r;
+//# sourceMappingURL=isEmpty.cjs.map

package/dist/typed/isEmpty.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"isEmpty.cjs","sources":["../../src/typed/isEmpty.ts"],"sourcesContent":["import { isArray } from './isArray';\nimport { isNil } from './isNil';\nimport { isObject } from './isObject';\n\n/**\n * Checks if the given argument is empty.\n *\n * @example\n * ```ts\n * isEmpty(null); // true\n * isEmpty(undefined); // true\n * isEmpty([]); // true\n * isEmpty({}); // true\n * isEmpty(''); // true\n * isEmpty(0); // false\n * isEmpty(123); // false\n * isEmpty('abc'); // false\n * isEmpty([1, 2, 3]); // false\n * isEmpty({ a: 1, b: 2 }); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if all arguments are `null`, `undefined`, `{}`, `[]`, or empty strings. Otherwise, it returns `false`.\n */\n// biome-ignore lint/suspicious/noExplicitAny: -\nexport function isEmpty(arg: any): boolean {\n  if (isNil(arg) || arg === '') return true;\n  if (isArray(arg)) return arg.length === 0;\n  if (arg instanceof Map || arg instanceof Set) return arg.size === 0;\n  if (isObject(arg)) return Object.keys(arg).length === 0;\n  return false;\n}\n\nexport const IS_EMPTY_ERROR_MSG = 'Expected an empty value';\n"],"names":["isEmpty","arg","isNil","isArray","isObject","IS_EMPTY_ERROR_MSG"],"mappings":"sKA0BO,SAASA,EAAQC,EAAmB,CACzC,OAAIC,EAAAA,MAAMD,CAAG,GAAKA,IAAQ,GAAW,GACjCE,EAAAA,QAAQF,CAAG,EAAUA,EAAI,SAAW,EACpCA,aAAe,KAAOA,aAAe,IAAYA,EAAI,OAAS,EAC9DG,EAAAA,SAASH,CAAG,EAAU,OAAO,KAAKA,CAAG,EAAE,SAAW,EAC/C,EACT,CAEO,MAAMI,EAAqB"}
+{"version":3,"file":"isEmpty.cjs","names":[],"sources":["../../src/typed/isEmpty.ts"],"sourcesContent":["import { isArray } from './isArray';\nimport { isNil } from './isNil';\nimport { isObject } from './isObject';\n\n/**\n * Checks if the given argument is empty.\n *\n * @example\n * ```ts\n * isEmpty(null); // true\n * isEmpty(undefined); // true\n * isEmpty([]); // true\n * isEmpty({}); // true\n * isEmpty(''); // true\n * isEmpty(0); // false\n * isEmpty(123); // false\n * isEmpty('abc'); // false\n * isEmpty([1, 2, 3]); // false\n * isEmpty({ a: 1, b: 2 }); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if all arguments are `null`, `undefined`, `{}`, `[]`, or empty strings. Otherwise, it returns `false`.\n */\nexport function isEmpty(arg: any): boolean {\n  if (isNil(arg) || arg === '') return true;\n\n  if (isArray(arg)) return arg.length === 0;\n\n  if (arg instanceof Map || arg instanceof Set) return arg.size === 0;\n\n  if (isObject(arg)) return Object.keys(arg).length === 0;\n\n  return false;\n}\n\nexport const IS_EMPTY_ERROR_MSG = 'Expected an empty value';\n"],"mappings":"sFAyBA,SAAgB,EAAQ,EAAmB,CASzC,OARI,EAAA,MAAM,EAAI,EAAI,IAAQ,GAAW,GAEjC,EAAA,QAAQ,EAAI,CAAS,EAAI,SAAW,EAEpC,aAAe,KAAO,aAAe,IAAY,EAAI,OAAS,EAE9D,EAAA,SAAS,EAAI,CAAS,OAAO,KAAK,EAAI,CAAC,SAAW,EAE/C"}

package/dist/typed/isEmpty.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Checks if the given argument is empty.
+ *
+ * @example
+ * ```ts
+ * isEmpty(null); // true
+ * isEmpty(undefined); // true
+ * isEmpty([]); // true
+ * isEmpty({}); // true
+ * isEmpty(''); // true
+ * isEmpty(0); // false
+ * isEmpty(123); // false
+ * isEmpty('abc'); // false
+ * isEmpty([1, 2, 3]); // false
+ * isEmpty({ a: 1, b: 2 }); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if all arguments are `null`, `undefined`, `{}`, `[]`, or empty strings. Otherwise, it returns `false`.
+ */
+export declare function isEmpty(arg: any): boolean;
+export declare const IS_EMPTY_ERROR_MSG = "Expected an empty value";
+//# sourceMappingURL=isEmpty.d.ts.map

package/dist/typed/isEmpty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEmpty.d.ts","sourceRoot":"","sources":["../../src/typed/isEmpty.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAUzC;AAED,eAAO,MAAM,kBAAkB,4BAA4B,CAAC"}

package/dist/typed/isEmpty.js

@@ -1,12 +1,11 @@
 import { isArray as e } from "./isArray.js";
-import { isNil as i } from "./isNil.js";
+import { isNil as t } from "./isNil.js";
 import { isObject as n } from "./isObject.js";
-function s(t) {
-  return i(t) || t === "" ? !0 : e(t) ? t.length === 0 : t instanceof Map || t instanceof Set ? t.size === 0 : n(t) ? Object.keys(t).length === 0 : !1;
+//#region src/typed/isEmpty.ts
+function r(r) {
+	return t(r) || r === "" ? !0 : e(r) ? r.length === 0 : r instanceof Map || r instanceof Set ? r.size === 0 : n(r) ? Object.keys(r).length === 0 : !1;
 }
-const m = "Expected an empty value";
-export {
-  m as IS_EMPTY_ERROR_MSG,
-  s as isEmpty
-};
-//# sourceMappingURL=isEmpty.js.map
+//#endregion
+export { r as isEmpty };
+
+//# sourceMappingURL=isEmpty.js.map

package/dist/typed/isEmpty.js.map

@@ -1 +1 @@
-{"version":3,"file":"isEmpty.js","sources":["../../src/typed/isEmpty.ts"],"sourcesContent":["import { isArray } from './isArray';\nimport { isNil } from './isNil';\nimport { isObject } from './isObject';\n\n/**\n * Checks if the given argument is empty.\n *\n * @example\n * ```ts\n * isEmpty(null); // true\n * isEmpty(undefined); // true\n * isEmpty([]); // true\n * isEmpty({}); // true\n * isEmpty(''); // true\n * isEmpty(0); // false\n * isEmpty(123); // false\n * isEmpty('abc'); // false\n * isEmpty([1, 2, 3]); // false\n * isEmpty({ a: 1, b: 2 }); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if all arguments are `null`, `undefined`, `{}`, `[]`, or empty strings. Otherwise, it returns `false`.\n */\n// biome-ignore lint/suspicious/noExplicitAny: -\nexport function isEmpty(arg: any): boolean {\n  if (isNil(arg) || arg === '') return true;\n  if (isArray(arg)) return arg.length === 0;\n  if (arg instanceof Map || arg instanceof Set) return arg.size === 0;\n  if (isObject(arg)) return Object.keys(arg).length === 0;\n  return false;\n}\n\nexport const IS_EMPTY_ERROR_MSG = 'Expected an empty value';\n"],"names":["isEmpty","arg","isNil","isArray","isObject","IS_EMPTY_ERROR_MSG"],"mappings":";;;AA0BO,SAASA,EAAQC,GAAmB;AACzC,SAAIC,EAAMD,CAAG,KAAKA,MAAQ,KAAW,KACjCE,EAAQF,CAAG,IAAUA,EAAI,WAAW,IACpCA,aAAe,OAAOA,aAAe,MAAYA,EAAI,SAAS,IAC9DG,EAASH,CAAG,IAAU,OAAO,KAAKA,CAAG,EAAE,WAAW,IAC/C;AACT;AAEO,MAAMI,IAAqB;"}
+{"version":3,"file":"isEmpty.js","names":[],"sources":["../../src/typed/isEmpty.ts"],"sourcesContent":["import { isArray } from './isArray';\nimport { isNil } from './isNil';\nimport { isObject } from './isObject';\n\n/**\n * Checks if the given argument is empty.\n *\n * @example\n * ```ts\n * isEmpty(null); // true\n * isEmpty(undefined); // true\n * isEmpty([]); // true\n * isEmpty({}); // true\n * isEmpty(''); // true\n * isEmpty(0); // false\n * isEmpty(123); // false\n * isEmpty('abc'); // false\n * isEmpty([1, 2, 3]); // false\n * isEmpty({ a: 1, b: 2 }); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if all arguments are `null`, `undefined`, `{}`, `[]`, or empty strings. Otherwise, it returns `false`.\n */\nexport function isEmpty(arg: any): boolean {\n  if (isNil(arg) || arg === '') return true;\n\n  if (isArray(arg)) return arg.length === 0;\n\n  if (arg instanceof Map || arg instanceof Set) return arg.size === 0;\n\n  if (isObject(arg)) return Object.keys(arg).length === 0;\n\n  return false;\n}\n\nexport const IS_EMPTY_ERROR_MSG = 'Expected an empty value';\n"],"mappings":";;;;AAyBA,SAAgB,EAAQ,GAAmB;AASzC,QARI,EAAM,EAAI,IAAI,MAAQ,KAAW,KAEjC,EAAQ,EAAI,GAAS,EAAI,WAAW,IAEpC,aAAe,OAAO,aAAe,MAAY,EAAI,SAAS,IAE9D,EAAS,EAAI,GAAS,OAAO,KAAK,EAAI,CAAC,WAAW,IAE/C"}

package/dist/typed/isEqual.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function l(e,r){return f(e,r,new WeakMap)}function f(e,r,n){if(e===r)return!0;if(e==null||r==null||typeof e!=typeof r||typeof e!="object"||typeof r!="object")return!1;if(n.has(e))return n.get(e)===r;if(n.set(e,r),Array.isArray(e)&&Array.isArray(r)){if(e.length!==r.length)return!1;for(let t=0;t<e.length;t++)if(!f(e[t],r[t],n))return!1;return!0}if(Array.isArray(e)!==Array.isArray(r))return!1;if(e instanceof Date&&r instanceof Date)return e.getTime()===r.getTime();const u=Object.keys(e),s=Object.keys(r);if(u.length!==s.length)return!1;for(const t of u)if(!Object.hasOwn(r,t)||!f(e[t],r[t],n))return!1;return!0}const o="Expected two values to be equal";exports.IS_EQUAL_ERROR_MSG=o;exports.isEqual=l;
-//# sourceMappingURL=isEqual.cjs.map
+function e(e,n){return t(e,n,new WeakMap)}function t(e,n,r){if(e===n)return!0;if(e==null||n==null||typeof e!=typeof n||typeof e!=`object`||typeof n!=`object`)return!1;if(r.has(e))return r.get(e)===n;if(r.set(e,n),Array.isArray(e)||Array.isArray(n))return!Array.isArray(e)||!Array.isArray(n)||e.length!==n.length?!1:e.every((e,i)=>t(e,n[i],r));if(e instanceof Date&&n instanceof Date)return e.getTime()===n.getTime();if(e instanceof Map&&n instanceof Map){if(e.size!==n.size)return!1;for(let[i,a]of e)if(!n.has(i)||!t(a,n.get(i),r))return!1;return!0}if(e instanceof Set&&n instanceof Set){if(e.size!==n.size)return!1;for(let i of e)if(![...n].some(e=>t(i,e,r)))return!1;return!0}let i=Object.keys(e),a=Object.keys(n);if(i.length!==a.length)return!1;for(let a of i)if(!Object.hasOwn(n,a)||!t(e[a],n[a],r))return!1;return!0}exports.isEqual=e;
+//# sourceMappingURL=isEqual.cjs.map