@vinicunca/perkakas 1.0.1 → 1.0.3

package/dist/is-error.spec-d.js

@@ -0,0 +1 @@
+import{a as o,b as a}from"./chunk-2VLHCBHJ.js";import{a as e}from"./chunk-7EMQYM4A.js";it("should work as type guard",()=>{let r=o.error;e(r)&&expectTypeOf(r).toEqualTypeOf();let t;e(t)&&expectTypeOf(t).toEqualTypeOf()});it("should work as type guard in filter",()=>{let r=a.filter(e);expectTypeOf(r).toEqualTypeOf()});

package/dist/is-function.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunkZCCHYKDGcjs = require('./chunk-ZCCHYKDG.cjs');it("should work as type guard",()=>{let e=_chunkZJGZ2TECcjs.a.function;_chunkZCCHYKDGcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf();let i;_chunkZCCHYKDGcjs.a.call(void 0, i)&&(i(1),expectTypeOf(i).toEqualTypeOf())});it("should work as type guard in filter",()=>{let e=_chunkZJGZ2TECcjs.b.filter(_chunkZCCHYKDGcjs.a);expectTypeOf(e).toEqualTypeOf()});

package/dist/is-function.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-function.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-function.spec-d.js

@@ -0,0 +1 @@
+import{a as r,b as a}from"./chunk-2VLHCBHJ.js";import{a as t}from"./chunk-VPHS3T3W.js";it("should work as type guard",()=>{let e=r.function;t(e)&&expectTypeOf(e).toEqualTypeOf();let i;t(i)&&(i(1),expectTypeOf(i).toEqualTypeOf())});it("should work as type guard in filter",()=>{let e=a.filter(t);expectTypeOf(e).toEqualTypeOf()});

package/dist/is-included-in.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkWFR3HBYRcjs = require('./chunk-WFR3HBYR.cjs');it("throws on bad value types",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,["yes","no"])});it("throws on non-overlapping (e.g. typo-proof)",()=>{_chunkWFR3HBYRcjs.a.call(void 0, "cat",["doog"])});describe("narrowing",()=>{test("data is single literal, container is pure tuple === NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1])?expectTypeOf(1).toEqualTypeOf():expectTypeOf(1).toBeNever()}),test("data is literal union, container is pure tuple === NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is single literal, container is array === NOT NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is literal union, container is array === NOT NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive, container is pure tuple of typeof data === NOT NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive, container is array of typeof data === NOT NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive, container is pure tuple of literals === NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive, container is array of literals === NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive union, container is pure tuple of literals === NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive union, container is pure tuple of primitives === NOT NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive union, container is array of primitives === NOT NARROWED",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("pure tuples with literal unions",()=>{_chunkWFR3HBYRcjs.a.call(void 0, 1,[1]),expectTypeOf(1).toEqualTypeOf()})});

package/dist/is-included-in.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-included-in.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-included-in.spec-d.js

@@ -0,0 +1 @@
+import{a}from"./chunk-75K2QEB3.js";it("throws on bad value types",()=>{a(1,["yes","no"])});it("throws on non-overlapping (e.g. typo-proof)",()=>{a("cat",["doog"])});describe("narrowing",()=>{test("data is single literal, container is pure tuple === NARROWED",()=>{a(1,[1])?expectTypeOf(1).toEqualTypeOf():expectTypeOf(1).toBeNever()}),test("data is literal union, container is pure tuple === NARROWED",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is single literal, container is array === NOT NARROWED",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is literal union, container is array === NOT NARROWED",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive, container is pure tuple of typeof data === NOT NARROWED",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive, container is array of typeof data === NOT NARROWED",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive, container is pure tuple of literals === NARROWED",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive, container is array of literals === NARROWED",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive union, container is pure tuple of literals === NARROWED",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive union, container is pure tuple of primitives === NOT NARROWED",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("data is primitive union, container is array of primitives === NOT NARROWED",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()}),test("pure tuples with literal unions",()=>{a(1,[1]),expectTypeOf(1).toEqualTypeOf()})});

package/dist/is-non-null.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunk7XMQFPW7cjs = require('./chunk-7XMQFPW7.cjs');test("should work as type guard",()=>{let e=_chunkZJGZ2TECcjs.a.date;_chunk7XMQFPW7cjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});test("should work as type guard in filter",()=>{let e=_chunkZJGZ2TECcjs.b.filter(_chunk7XMQFPW7cjs.a);expectTypeOf(e).toEqualTypeOf(e)});

package/dist/is-non-null.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-non-null.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-non-null.spec-d.js

@@ -0,0 +1 @@
+import{a as t,b as s}from"./chunk-2VLHCBHJ.js";import{a as r}from"./chunk-6BKLAQWR.js";test("should work as type guard",()=>{let e=t.date;r(e)&&expectTypeOf(e).toEqualTypeOf()});test("should work as type guard in filter",()=>{let e=s.filter(r);expectTypeOf(e).toEqualTypeOf(e)});

package/dist/is-non-nullish.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunkDAFN5EJRcjs = require('./chunk-DAFN5EJR.cjs');it("should work as type guard",()=>{let r=_chunkZJGZ2TECcjs.a.date;_chunkDAFN5EJRcjs.a.call(void 0, r)&&expectTypeOf(r).toEqualTypeOf()});it("should work as type guard in filter",()=>{let r=_chunkZJGZ2TECcjs.b.filter(_chunkDAFN5EJRcjs.a);expectTypeOf(r).toEqualTypeOf()});

package/dist/is-non-nullish.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-non-nullish.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-non-nullish.spec-d.js

@@ -0,0 +1 @@
+import{a as t,b as a}from"./chunk-2VLHCBHJ.js";import{a as e}from"./chunk-QPP664N4.js";it("should work as type guard",()=>{let r=t.date;e(r)&&expectTypeOf(r).toEqualTypeOf()});it("should work as type guard in filter",()=>{let r=a.filter(e);expectTypeOf(r).toEqualTypeOf()});

package/dist/is-not.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunkWM4KSO6Ccjs = require('./chunk-WM4KSO6C.cjs');var _chunkU3OEHN5Pcjs = require('./chunk-U3OEHN5P.cjs');var _chunkEHJK4JRFcjs = require('./chunk-EHJK4JRF.cjs');it("should work as type guard",()=>{let r=_chunkZJGZ2TECcjs.a.promise;_chunkU3OEHN5Pcjs.a.call(void 0, (0, _chunkEHJK4JRFcjs.a))(r)&&expectTypeOf(r).toEqualTypeOf(r)});it("should work as type guard in filter",()=>{let r=_chunkZJGZ2TECcjs.b.filter(_chunkU3OEHN5Pcjs.a.call(void 0, _chunkWM4KSO6Ccjs.a));expectTypeOf(r).toEqualTypeOf()});

package/dist/is-not.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-not.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-not.spec-d.js

@@ -0,0 +1 @@
+import{a as n,b as a}from"./chunk-2VLHCBHJ.js";import{a as s}from"./chunk-HFNVS6OX.js";import{a as e}from"./chunk-G73S4IVJ.js";import{a as t}from"./chunk-UYLVIAK4.js";it("should work as type guard",()=>{let r=n.promise;e(t)(r)&&expectTypeOf(r).toEqualTypeOf(r)});it("should work as type guard in filter",()=>{let r=a.filter(e(s));expectTypeOf(r).toEqualTypeOf()});

package/dist/is-nullish.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunkXUEOOIR6cjs = require('./chunk-XUEOOIR6.cjs');it("narrows nulls",()=>{_chunkXUEOOIR6cjs.a.call(void 0, 123)?expectTypeOf(123).toBeNull():expectTypeOf(123).toBeNumber()});it("narrows undefined",()=>{_chunkXUEOOIR6cjs.a.call(void 0, 123)?expectTypeOf(123).toBeUndefined():expectTypeOf(123).toBeNumber()});it("narrows on both",()=>{_chunkXUEOOIR6cjs.a.call(void 0, 123)?expectTypeOf(123).toEqualTypeOf():expectTypeOf(123).toBeNumber()});it("doesn't narrow non-nullables",()=>{_chunkXUEOOIR6cjs.a.call(void 0, 123)?expectTypeOf(123).toBeNever():expectTypeOf(123).toBeNumber()});it("narrows unknowns",()=>{_chunkXUEOOIR6cjs.a.call(void 0, 123)?expectTypeOf(123).toEqualTypeOf():expectTypeOf(123).toBeUnknown()});it("narrows any",()=>{_chunkXUEOOIR6cjs.a.call(void 0, 123)?expectTypeOf(123).toEqualTypeOf():expectTypeOf(123).toBeAny()});it("doesn't expand narrow types",()=>{let e="cat";_chunkXUEOOIR6cjs.a.call(void 0, e),expectTypeOf(e).toEqualTypeOf()});it("should work as type guard in filter",()=>{let e=_chunkZJGZ2TECcjs.b.filter(_chunkXUEOOIR6cjs.a);expectTypeOf(e).toEqualTypeOf()});

package/dist/is-nullish.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-nullish.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-nullish.spec-d.js

@@ -0,0 +1 @@
+import{b as a}from"./chunk-2VLHCBHJ.js";import{a as t}from"./chunk-TBXEXWSK.js";it("narrows nulls",()=>{t(123)?expectTypeOf(123).toBeNull():expectTypeOf(123).toBeNumber()});it("narrows undefined",()=>{t(123)?expectTypeOf(123).toBeUndefined():expectTypeOf(123).toBeNumber()});it("narrows on both",()=>{t(123)?expectTypeOf(123).toEqualTypeOf():expectTypeOf(123).toBeNumber()});it("doesn't narrow non-nullables",()=>{t(123)?expectTypeOf(123).toBeNever():expectTypeOf(123).toBeNumber()});it("narrows unknowns",()=>{t(123)?expectTypeOf(123).toEqualTypeOf():expectTypeOf(123).toBeUnknown()});it("narrows any",()=>{t(123)?expectTypeOf(123).toEqualTypeOf():expectTypeOf(123).toBeAny()});it("doesn't expand narrow types",()=>{let e="cat";t(e),expectTypeOf(e).toEqualTypeOf()});it("should work as type guard in filter",()=>{let e=a.filter(t);expectTypeOf(e).toEqualTypeOf()});

package/dist/is-number.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunkYWTY4X2Rcjs = require('./chunk-YWTY4X2R.cjs');var r=()=>1;it("should work as type guard",()=>{let e=_chunkZJGZ2TECcjs.a.number;_chunkYWTY4X2Rcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});it("should work as type guard in filter",()=>{let e=_chunkZJGZ2TECcjs.b.filter(_chunkYWTY4X2Rcjs.a);expectTypeOf(e).toEqualTypeOf()});it("should work even if data type is unknown",()=>{let e=_chunkZJGZ2TECcjs.a.number;_chunkYWTY4X2Rcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});it("should work with literal types",()=>{let e=r();_chunkYWTY4X2Rcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf(e)});

package/dist/is-number.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-number.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-number.spec-d.js

@@ -0,0 +1 @@
+import{a,b as o}from"./chunk-2VLHCBHJ.js";import{a as t}from"./chunk-Q2HW4RVT.js";var r=()=>1;it("should work as type guard",()=>{let e=a.number;t(e)&&expectTypeOf(e).toEqualTypeOf()});it("should work as type guard in filter",()=>{let e=o.filter(t);expectTypeOf(e).toEqualTypeOf()});it("should work even if data type is unknown",()=>{let e=a.number;t(e)&&expectTypeOf(e).toEqualTypeOf()});it("should work with literal types",()=>{let e=r();t(e)&&expectTypeOf(e).toEqualTypeOf(e)});

package/dist/is-object-type.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkVD6VNORFcjs = require('./chunk-VD6VNORF.cjs');exports.isObjectType = _chunkVD6VNORFcjs.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkR3TYGYBQcjs = require('./chunk-R3TYGYBQ.cjs');exports.isObjectType = _chunkR3TYGYBQcjs.a;

package/dist/is-object-type.d.cts

@@ -4,9 +4,11 @@ import 'type-fest';
 /**
  * Checks if the given parameter is of type `"object"` via `typeof`, excluding `null`.
  *
- * It's important to note that in JavaScript, many entities are considered objects, like Arrays, Classes, RegExps, Maps, Sets, Dates, URLs, Promise, Errors, and more. Although technically an object too, `null` is not considered an object by this function, so that its easier to narrow nullables.
+ * It's important to note that in JavaScript, many entities are considered objects, like Arrays, Classes, RegExps, Maps, Sets, Dates, URLs, Promise, Errors, and more.\
+ * Although technically an object too, `null` is not considered an object by this function, so that its easier to narrow nullables.
  *
- * For a more specific check that is limited to plain objects (simple struct/shape/record-like objects), consider using `isPlainObject` instead. For a simpler check that only removes `null` from the type prefer `isNonNull` or `isDefined`.
+ * For a more specific check that is limited to plain objects (simple struct/shape/record-like objects), consider using `isPlainObject` instead.
+ * For a simpler check that only removes `null` from the type prefer `isNonNull` or `isDefined`.
  *
  * @param data - The variable to be checked for being an object type.
  * @returns The input type, narrowed to only objects.
@@ -26,6 +28,6 @@ import 'type-fest';
  * @dataFirst
  * @category Guard
  */
-declare const isObjectType: <T>(data: T | object) => data is NarrowedTo<T, object>;
+declare function isObjectType<T>(data: T | object): data is NarrowedTo<T, object>;
 
 export { isObjectType };

package/dist/is-object-type.d.ts

@@ -4,9 +4,11 @@ import 'type-fest';
 /**
  * Checks if the given parameter is of type `"object"` via `typeof`, excluding `null`.
  *
- * It's important to note that in JavaScript, many entities are considered objects, like Arrays, Classes, RegExps, Maps, Sets, Dates, URLs, Promise, Errors, and more. Although technically an object too, `null` is not considered an object by this function, so that its easier to narrow nullables.
+ * It's important to note that in JavaScript, many entities are considered objects, like Arrays, Classes, RegExps, Maps, Sets, Dates, URLs, Promise, Errors, and more.\
+ * Although technically an object too, `null` is not considered an object by this function, so that its easier to narrow nullables.
  *
- * For a more specific check that is limited to plain objects (simple struct/shape/record-like objects), consider using `isPlainObject` instead. For a simpler check that only removes `null` from the type prefer `isNonNull` or `isDefined`.
+ * For a more specific check that is limited to plain objects (simple struct/shape/record-like objects), consider using `isPlainObject` instead.
+ * For a simpler check that only removes `null` from the type prefer `isNonNull` or `isDefined`.
  *
  * @param data - The variable to be checked for being an object type.
  * @returns The input type, narrowed to only objects.
@@ -26,6 +28,6 @@ import 'type-fest';
  * @dataFirst
  * @category Guard
  */
-declare const isObjectType: <T>(data: T | object) => data is NarrowedTo<T, object>;
+declare function isObjectType<T>(data: T | object): data is NarrowedTo<T, object>;
 
 export { isObjectType };

package/dist/is-object-type.js

@@ -1 +1 @@
-import{a}from"./chunk-6SQ2YEMB.js";export{a as isObjectType};
+import{a}from"./chunk-EBS4GCKX.js";export{a as isObjectType};

package/dist/is-object-type.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunkR3TYGYBQcjs = require('./chunk-R3TYGYBQ.cjs');test("narrows nullable types",()=>{let e={a:"hello"};_chunkR3TYGYBQcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});test("should work as type guard",()=>{let e=_chunkZJGZ2TECcjs.a.object;_chunkR3TYGYBQcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});test("should work even if data type is unknown",()=>{let e=_chunkZJGZ2TECcjs.a.object;_chunkR3TYGYBQcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});test("should work as type guard in filter",()=>{let e=_chunkZJGZ2TECcjs.b.filter(_chunkR3TYGYBQcjs.a);expectTypeOf(e).toEqualTypeOf()});test("Can narrow down `any`",()=>{let e={hello:"world"};_chunkR3TYGYBQcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});

package/dist/is-object-type.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-object-type.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-object-type.spec-d.js

@@ -0,0 +1 @@
+import{a as r,b as a}from"./chunk-2VLHCBHJ.js";import{a as t}from"./chunk-EBS4GCKX.js";test("narrows nullable types",()=>{let e={a:"hello"};t(e)&&expectTypeOf(e).toEqualTypeOf()});test("should work as type guard",()=>{let e=r.object;t(e)&&expectTypeOf(e).toEqualTypeOf()});test("should work even if data type is unknown",()=>{let e=r.object;t(e)&&expectTypeOf(e).toEqualTypeOf()});test("should work as type guard in filter",()=>{let e=a.filter(t);expectTypeOf(e).toEqualTypeOf()});test("Can narrow down `any`",()=>{let e={hello:"world"};t(e)&&expectTypeOf(e).toEqualTypeOf()});

package/dist/is-plain-object.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunk5AIMRZXJcjs = require('./chunk-5AIMRZXJ.cjs');test("narrows readonly records",()=>{let e={a:123};_chunk5AIMRZXJcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});test("narrows mixed records",()=>{let e={a:123,b:!1};_chunk5AIMRZXJcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});test("should work as type guard",()=>{let e=_chunkZJGZ2TECcjs.a.object;_chunk5AIMRZXJcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});test("should work even if data type is unknown",()=>{let e=_chunkZJGZ2TECcjs.a.object;_chunk5AIMRZXJcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});test("should work as type guard in filter",()=>{let e=_chunkZJGZ2TECcjs.b.filter(_chunk5AIMRZXJcjs.a);expectTypeOf(e).toEqualTypeOf()});test("Can narrow down `any`",()=>{let e={hello:"world"};_chunk5AIMRZXJcjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});

package/dist/is-plain-object.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-plain-object.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-plain-object.spec-d.js

@@ -0,0 +1 @@
+import{a as o,b as t}from"./chunk-2VLHCBHJ.js";import{a}from"./chunk-HLL46USD.js";test("narrows readonly records",()=>{let e={a:123};a(e)&&expectTypeOf(e).toEqualTypeOf()});test("narrows mixed records",()=>{let e={a:123,b:!1};a(e)&&expectTypeOf(e).toEqualTypeOf()});test("should work as type guard",()=>{let e=o.object;a(e)&&expectTypeOf(e).toEqualTypeOf()});test("should work even if data type is unknown",()=>{let e=o.object;a(e)&&expectTypeOf(e).toEqualTypeOf()});test("should work as type guard in filter",()=>{let e=t.filter(a);expectTypeOf(e).toEqualTypeOf()});test("Can narrow down `any`",()=>{let e={hello:"world"};a(e)&&expectTypeOf(e).toEqualTypeOf()});

package/dist/is-promise.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunkWM4KSO6Ccjs = require('./chunk-WM4KSO6C.cjs');it("should work as type guard",()=>{let e=_chunkZJGZ2TECcjs.a.promise;_chunkWM4KSO6Ccjs.a.call(void 0, e)&&expectTypeOf(e).toEqualTypeOf()});it("should work as type guard in filter",()=>{let e=_chunkZJGZ2TECcjs.b.filter(_chunkWM4KSO6Ccjs.a);expectTypeOf(e).toEqualTypeOf()});

package/dist/is-promise.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-promise.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-promise.spec-d.js

@@ -0,0 +1 @@
+import{a as t,b as o}from"./chunk-2VLHCBHJ.js";import{a as r}from"./chunk-HFNVS6OX.js";it("should work as type guard",()=>{let e=t.promise;r(e)&&expectTypeOf(e).toEqualTypeOf()});it("should work as type guard in filter",()=>{let e=o.filter(r);expectTypeOf(e).toEqualTypeOf()});

package/dist/is-shallow-equal.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkT7S2RC5Mcjs = require('./chunk-T7S2RC5M.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.isShallowEqual = _chunkT7S2RC5Mcjs.a;

package/dist/is-shallow-equal.d.cts

@@ -0,0 +1,69 @@
+/**
+ * Performs a *shallow structural* comparison between two values to determine if
+ * they are equivalent. For primitive values this is equivalent to `===`, for
+ * arrays a **strict equality** check would be performed on every item, in
+ * order, and for objects props will be matched and checked for **strict
+ * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
+ * item and value.
+ *
+ * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they
+ * are semantically different (e.g. resolved promises); but `isDeepEqual` does
+ * compare the latter 2 semantically by-value.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isStrictEqual` if you don't need a deep comparison and just want to check
+ * for simple (`===`, `Object.is`) equality.
+ * - `isDeepEqual` for a recursively deep check of arrays and objects.
+ *
+ * @param data - The first value to compare.
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isShallowEqual(data, other)
+ * @example
+ *    P.isShallowEqual(1, 1) //=> true
+ *    P.isShallowEqual(1, '1') //=> false
+ *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true
+ *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare function isShallowEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
+declare function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;
+/**
+ * Performs a *shallow structural* comparison between two values to determine if
+ * they are equivalent. For primitive values this is equivalent to `===`, for
+ * arrays a **strict equality** check would be performed on every item, in
+ * order, and for objects props will be matched and checked for **strict
+ * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
+ * item and value.
+ *
+ * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,
+ * even when they are semantically different (e.g. resolved promises). Use
+ * `isDeepEqual` instead.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isStrictEqual` if you don't need a deep comparison and just want to check
+ * for simple (`===`, `Object.is`) equality.
+ * - `isDeepEqual` for a recursively deep check of arrays and objects.
+ *
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isShallowEqual(other)(data)
+ * @example
+ *    P.pipe(1, P.isShallowEqual(1)) //=> true
+ *    P.pipe(1, P.isShallowEqual('1')) //=> false
+ *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true
+ *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare function isShallowEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
+declare function isShallowEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
+
+export { isShallowEqual };

package/dist/is-shallow-equal.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Performs a *shallow structural* comparison between two values to determine if
+ * they are equivalent. For primitive values this is equivalent to `===`, for
+ * arrays a **strict equality** check would be performed on every item, in
+ * order, and for objects props will be matched and checked for **strict
+ * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
+ * item and value.
+ *
+ * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they
+ * are semantically different (e.g. resolved promises); but `isDeepEqual` does
+ * compare the latter 2 semantically by-value.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isStrictEqual` if you don't need a deep comparison and just want to check
+ * for simple (`===`, `Object.is`) equality.
+ * - `isDeepEqual` for a recursively deep check of arrays and objects.
+ *
+ * @param data - The first value to compare.
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isShallowEqual(data, other)
+ * @example
+ *    P.isShallowEqual(1, 1) //=> true
+ *    P.isShallowEqual(1, '1') //=> false
+ *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true
+ *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare function isShallowEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
+declare function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;
+/**
+ * Performs a *shallow structural* comparison between two values to determine if
+ * they are equivalent. For primitive values this is equivalent to `===`, for
+ * arrays a **strict equality** check would be performed on every item, in
+ * order, and for objects props will be matched and checked for **strict
+ * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
+ * item and value.
+ *
+ * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,
+ * even when they are semantically different (e.g. resolved promises). Use
+ * `isDeepEqual` instead.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isStrictEqual` if you don't need a deep comparison and just want to check
+ * for simple (`===`, `Object.is`) equality.
+ * - `isDeepEqual` for a recursively deep check of arrays and objects.
+ *
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isShallowEqual(other)(data)
+ * @example
+ *    P.pipe(1, P.isShallowEqual(1)) //=> true
+ *    P.pipe(1, P.isShallowEqual('1')) //=> false
+ *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true
+ *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare function isShallowEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
+declare function isShallowEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
+
+export { isShallowEqual };

package/dist/is-shallow-equal.js

@@ -0,0 +1 @@
+import{a}from"./chunk-2ADWP73S.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as isShallowEqual};

package/dist/is-shallow-equal.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkT7S2RC5Mcjs = require('./chunk-T7S2RC5M.cjs');var _chunkKITVKWLPcjs = require('./chunk-KITVKWLP.cjs');require('./chunk-NLX7PGPI.cjs');require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');it("narrows unions",()=>{_chunkT7S2RC5Mcjs.a.call(void 0, 1,1),expectTypeOf(1).toEqualTypeOf(),_chunkT7S2RC5Mcjs.a.call(void 0, 1,"hello"),expectTypeOf(1).toEqualTypeOf()});it("narrows to literal",()=>{_chunkT7S2RC5Mcjs.a.call(void 0, 1,1),expectTypeOf(1).toEqualTypeOf()});it("doesn't accept non-overlapping types",()=>{_chunkT7S2RC5Mcjs.a.call(void 0, 1,!0)});it("works deeply",()=>{let e=[];_chunkT7S2RC5Mcjs.a.call(void 0, e,[{a:[1]}]),expectTypeOf(e).toEqualTypeOf()});it("doesn't narrow when comparing objects of the same type",()=>{let e={a:1};_chunkT7S2RC5Mcjs.a.call(void 0, e,{a:2}),expectTypeOf(e).toEqualTypeOf()});it("headless usage can infer types",()=>{let e=_chunkKITVKWLPcjs.a.call(void 0, ["a","b","c"],["a","c","d"],_chunkT7S2RC5Mcjs.a);expectTypeOf(e).toEqualTypeOf()});

package/dist/is-shallow-equal.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-shallow-equal.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-shallow-equal.spec-d.js

@@ -0,0 +1 @@
+import{a}from"./chunk-2ADWP73S.js";import{a as t}from"./chunk-UNKQWZT6.js";import"./chunk-C6L5NLLB.js";import"./chunk-6ALZHU2N.js";import"./chunk-MYLYERXO.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";it("narrows unions",()=>{a(1,1),expectTypeOf(1).toEqualTypeOf(),a(1,"hello"),expectTypeOf(1).toEqualTypeOf()});it("narrows to literal",()=>{a(1,1),expectTypeOf(1).toEqualTypeOf()});it("doesn't accept non-overlapping types",()=>{a(1,!0)});it("works deeply",()=>{let e=[];a(e,[{a:[1]}]),expectTypeOf(e).toEqualTypeOf()});it("doesn't narrow when comparing objects of the same type",()=>{let e={a:1};a(e,{a:2}),expectTypeOf(e).toEqualTypeOf()});it("headless usage can infer types",()=>{let e=t(["a","b","c"],["a","c","d"],a);expectTypeOf(e).toEqualTypeOf()});

package/dist/is-strict-equal.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkVAUOPMANcjs = require('./chunk-VAUOPMAN.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.isStrictEqual = _chunkVAUOPMANcjs.a;

package/dist/is-strict-equal.d.cts

@@ -0,0 +1,65 @@
+/**
+ * Determines whether two values are *functionally identical* in all contexts.
+ * For primitive values (string, number), this is done by-value, and for objects
+ * it is done by-reference (i.e., they point to the same object in memory).
+ *
+ * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
+ * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`
+ * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas
+ * `Object.is(-0, 0) === false`).
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isDeepEqual` for a semantic comparison that allows comparing arrays and
+ * objects "by-value", and recurses for every item.
+ * - `isShallowEqual` if you need to compare arrays and objects "by-value" but
+ * don't want to recurse into their values.
+ *
+ * @param data - The first value to compare.
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isStrictEqual(data, other)
+ * @example
+ *    P.isStrictEqual(1, 1) //=> true
+ *    P.isStrictEqual(1, '1') //=> false
+ *    P.isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare function isStrictEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
+declare function isStrictEqual<T, S extends T = T>(data: T, other: S): boolean;
+/**
+ * Determines whether two values are *functionally identical* in all contexts.
+ * For primitive values (string, number), this is done by-value, and for objects
+ * it is done by-reference (i.e., they point to the same object in memory).
+ *
+ * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
+ * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`
+ * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas
+ * `Object.is(-0, 0) === false`).
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isDeepEqual` for a semantic comparison that allows comparing arrays and
+ * objects "by-value", and recurses for every item.
+ * - `isShallowEqual` if you need to compare arrays and objects "by-value" but
+ * don't want to recurse into their values.
+ *
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isStrictEqual(other)(data)
+ * @example
+ *    P.pipe(1, P.isStrictEqual(1)); //=> true
+ *    P.pipe(1, P.isStrictEqual('1')); //=> false
+ *    P.pipe([1, 2, 3], P.isStrictEqual([1, 2, 3])); //=> false
+ * @dataLast
+ * @category Guard
+ */
+declare function isStrictEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
+declare function isStrictEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
+
+export { isStrictEqual };

package/dist/is-strict-equal.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Determines whether two values are *functionally identical* in all contexts.
+ * For primitive values (string, number), this is done by-value, and for objects
+ * it is done by-reference (i.e., they point to the same object in memory).
+ *
+ * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
+ * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`
+ * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas
+ * `Object.is(-0, 0) === false`).
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isDeepEqual` for a semantic comparison that allows comparing arrays and
+ * objects "by-value", and recurses for every item.
+ * - `isShallowEqual` if you need to compare arrays and objects "by-value" but
+ * don't want to recurse into their values.
+ *
+ * @param data - The first value to compare.
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isStrictEqual(data, other)
+ * @example
+ *    P.isStrictEqual(1, 1) //=> true
+ *    P.isStrictEqual(1, '1') //=> false
+ *    P.isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare function isStrictEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
+declare function isStrictEqual<T, S extends T = T>(data: T, other: S): boolean;
+/**
+ * Determines whether two values are *functionally identical* in all contexts.
+ * For primitive values (string, number), this is done by-value, and for objects
+ * it is done by-reference (i.e., they point to the same object in memory).
+ *
+ * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
+ * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`
+ * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas
+ * `Object.is(-0, 0) === false`).
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isDeepEqual` for a semantic comparison that allows comparing arrays and
+ * objects "by-value", and recurses for every item.
+ * - `isShallowEqual` if you need to compare arrays and objects "by-value" but
+ * don't want to recurse into their values.
+ *
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isStrictEqual(other)(data)
+ * @example
+ *    P.pipe(1, P.isStrictEqual(1)); //=> true
+ *    P.pipe(1, P.isStrictEqual('1')); //=> false
+ *    P.pipe([1, 2, 3], P.isStrictEqual([1, 2, 3])); //=> false
+ * @dataLast
+ * @category Guard
+ */
+declare function isStrictEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
+declare function isStrictEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
+
+export { isStrictEqual };

package/dist/is-strict-equal.js

@@ -0,0 +1 @@
+import{a}from"./chunk-HU67VIVI.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as isStrictEqual};

package/dist/is-strict-equal.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkVAUOPMANcjs = require('./chunk-VAUOPMAN.cjs');var _chunkKITVKWLPcjs = require('./chunk-KITVKWLP.cjs');require('./chunk-NLX7PGPI.cjs');require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');it("narrows unions",()=>{_chunkVAUOPMANcjs.a.call(void 0, 1,1),expectTypeOf(1).toEqualTypeOf(),_chunkVAUOPMANcjs.a.call(void 0, 1,"hello"),expectTypeOf(1).toEqualTypeOf()});it("narrows to literal",()=>{_chunkVAUOPMANcjs.a.call(void 0, 1,1),expectTypeOf(1).toEqualTypeOf()});it("doesn't accept non-overlapping types",()=>{_chunkVAUOPMANcjs.a.call(void 0, 1,!0)});it("works deeply",()=>{let e=[];_chunkVAUOPMANcjs.a.call(void 0, e,[{a:[1]}]),expectTypeOf(e).toEqualTypeOf()});it("doesn't narrow when comparing objects of the same type",()=>{let e={a:1};_chunkVAUOPMANcjs.a.call(void 0, e,{a:2}),expectTypeOf(e).toEqualTypeOf()});it("headless usage can infer types",()=>{let e=_chunkKITVKWLPcjs.a.call(void 0, ["a","b","c"],["a","c","d"],_chunkVAUOPMANcjs.a);expectTypeOf(e).toEqualTypeOf()});

package/dist/is-strict-equal.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-strict-equal.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-strict-equal.spec-d.js

@@ -0,0 +1 @@
+import{a}from"./chunk-HU67VIVI.js";import{a as t}from"./chunk-UNKQWZT6.js";import"./chunk-C6L5NLLB.js";import"./chunk-6ALZHU2N.js";import"./chunk-MYLYERXO.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";it("narrows unions",()=>{a(1,1),expectTypeOf(1).toEqualTypeOf(),a(1,"hello"),expectTypeOf(1).toEqualTypeOf()});it("narrows to literal",()=>{a(1,1),expectTypeOf(1).toEqualTypeOf()});it("doesn't accept non-overlapping types",()=>{a(1,!0)});it("works deeply",()=>{let e=[];a(e,[{a:[1]}]),expectTypeOf(e).toEqualTypeOf()});it("doesn't narrow when comparing objects of the same type",()=>{let e={a:1};a(e,{a:2}),expectTypeOf(e).toEqualTypeOf()});it("headless usage can infer types",()=>{let e=t(["a","b","c"],["a","c","d"],a);expectTypeOf(e).toEqualTypeOf()});

package/dist/is-string.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunkEHJK4JRFcjs = require('./chunk-EHJK4JRF.cjs');var o=()=>"a";it("should work as type guard",()=>{let t=_chunkZJGZ2TECcjs.a.string;_chunkEHJK4JRFcjs.a.call(void 0, t)&&expectTypeOf(t).toEqualTypeOf()});it("should work even if data type is unknown",()=>{let t=_chunkZJGZ2TECcjs.a.string;_chunkEHJK4JRFcjs.a.call(void 0, t)&&expectTypeOf(t).toEqualTypeOf()});it("should work with literal types",()=>{let t=o();_chunkEHJK4JRFcjs.a.call(void 0, t)&&expectTypeOf(t).toEqualTypeOf()});it("should work as type guard in array",()=>{let t=_chunkZJGZ2TECcjs.b.filter(_chunkEHJK4JRFcjs.a);expectTypeOf(t).toEqualTypeOf()});

package/dist/is-string.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-string.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-string.spec-d.js

@@ -0,0 +1 @@
+import{a,b as r}from"./chunk-2VLHCBHJ.js";import{a as e}from"./chunk-UYLVIAK4.js";var o=()=>"a";it("should work as type guard",()=>{let t=a.string;e(t)&&expectTypeOf(t).toEqualTypeOf()});it("should work even if data type is unknown",()=>{let t=a.string;e(t)&&expectTypeOf(t).toEqualTypeOf()});it("should work with literal types",()=>{let t=o();e(t)&&expectTypeOf(t).toEqualTypeOf()});it("should work as type guard in array",()=>{let t=r.filter(e);expectTypeOf(t).toEqualTypeOf()});

package/dist/is-symbol.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkZJGZ2TECcjs = require('./chunk-ZJGZ2TEC.cjs');var _chunkSW62SX4Ycjs = require('./chunk-SW62SX4Y.cjs');it("should work as type guard",()=>{let a=_chunkZJGZ2TECcjs.a.symbol;_chunkSW62SX4Ycjs.a.call(void 0, a)&&expectTypeOf(a).toEqualTypeOf()});it("should work even if data type is `unknown`",()=>{let a=_chunkZJGZ2TECcjs.a.symbol;_chunkSW62SX4Ycjs.a.call(void 0, a)&&expectTypeOf(a).toEqualTypeOf()});it("should work even if data type is `any`",()=>{let a=_chunkZJGZ2TECcjs.a.symbol;_chunkSW62SX4Ycjs.a.call(void 0, a)&&expectTypeOf(a).toEqualTypeOf()});it("should work as type guard in array",()=>{let a=_chunkZJGZ2TECcjs.b.filter(_chunkSW62SX4Ycjs.a);expectTypeOf(a).toEqualTypeOf()});

package/dist/is-symbol.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-symbol.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-symbol.spec-d.js

@@ -0,0 +1 @@
+import{a as o,b as t}from"./chunk-2VLHCBHJ.js";import{a as e}from"./chunk-YBJMFRB6.js";it("should work as type guard",()=>{let a=o.symbol;e(a)&&expectTypeOf(a).toEqualTypeOf()});it("should work even if data type is `unknown`",()=>{let a=o.symbol;e(a)&&expectTypeOf(a).toEqualTypeOf()});it("should work even if data type is `any`",()=>{let a=o.symbol;e(a)&&expectTypeOf(a).toEqualTypeOf()});it("should work as type guard in array",()=>{let a=t.filter(e);expectTypeOf(a).toEqualTypeOf()});

package/dist/is-truthy.spec-d.cjs

@@ -0,0 +1 @@
+"use strict";var _chunkOFLOVIU2cjs = require('./chunk-OFLOVIU2.cjs');test("isTruthy",()=>{let t={a:"asd"};_chunkOFLOVIU2cjs.a.call(void 0, t)&&expectTypeOf(t).toEqualTypeOf()});

package/dist/is-truthy.spec-d.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-truthy.spec-d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/is-truthy.spec-d.js

@@ -0,0 +1 @@
+import{a}from"./chunk-RFHE6DOJ.js";test("isTruthy",()=>{let t={a:"asd"};a(t)&&expectTypeOf(t).toEqualTypeOf()});