@vinicunca/perkakas 1.15.0 → 1.16.0

package/dist/is-emptyish.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-emptyish.js","names":[],"sources":["../src/is-emptyish.ts"],"sourcesContent":["import type {\n  And,\n  HasRequiredKeys,\n  IsAny,\n  IsEqual,\n  IsNever,\n  IsNumericLiteral,\n  IsUnknown,\n  OmitIndexSignature,\n  Or,\n  Tagged,\n  ValueOf,\n} from 'type-fest';\nimport type { HasWritableKeys } from './internal/types/has-writable-keys';\nimport type { TupleParts } from './internal/types/tuple-parts';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- we use a non-exported unique symbol to prevent users from faking our return type.\ndeclare const EMPTYISH_BRAND: unique symbol;\n\n// Because our function is a type-predicate and it narrows the input based on\n// the result of our type, we sometimes need a way to \"turn off\" narrowing while\n// still returning the input type. By tagging/branding our return type we stop\n// TypeScript from narrowing it while still allowing it to be used as if it was\n// the input type (because it still extends the type).\ntype Empty<T> = Tagged<T, typeof EMPTYISH_BRAND>;\n\n// The goal of this type is to return the empty \"view\" of the input type. This\n// makes it possible for TypeScript to narrow it precisely.\ntype Emptyish<T>\n  // There are effectively 4 types that can be empty:\n  = | (T extends string ? '' : never)\n    | (T extends object ? EmptyishObjectLike<T> : never)\n    | (T extends null ? null : never)\n    | (T extends undefined ? undefined : never);\n\n// Because of TypeScript's duck-typing, a lot of sub-types of `object` can\n// extend each other so we need to cascade between the different \"kinds\" of\n// objects.\ntype EmptyishObjectLike<T extends object> = T extends ReadonlyArray<unknown>\n  ? EmptyishArray<T>\n  : T extends ReadonlyMap<infer Key, unknown>\n    ? T extends Map<unknown, unknown>\n      ? // Mutable maps should remain mutable so we can't narrow them down.\n      Empty<T>\n      : // But immutable maps could be rewritten to prevent any mutations.\n      ReadonlyMap<Key, never>\n    : T extends ReadonlySet<unknown>\n      ? T extends Set<unknown>\n        ? // Mutable sets should remain mutable so we can't narrow them down.\n        Empty<T>\n        : // But immutable sets could be rewritten to prevent any mutations.\n        ReadonlySet<never>\n      : EmptyishObject<T>;\n\ntype EmptyishArray<T extends ReadonlyArray<unknown>> = T extends readonly []\n  ? // By returning T we effectively narrow the \"else\" branch to `never`.\n  T\n  : And<\n    IsEqual<TupleParts<T>['required'], []>,\n    IsEqual<TupleParts<T>['suffix'], []>\n  > extends true\n    ? T extends Array<unknown>\n      ? // A mutable array should remain mutable so we can't narrow it down.\n      Empty<T>\n      : // But immutable arrays could be rewritten to prevent any mutations.\n      readonly []\n    : // An array with a required prefix or suffix would never be empty, we can\n  // use that fact to narrow the \"if\" branch to `never`.\n    never;\n\ntype EmptyishObject<T extends object> = T extends {\n  length: infer Length extends number;\n}\n  ? T extends string\n    ? // When a string is tagged/branded it also extends `object` and also has\n  // a `length` prop so we need to prevent handling it because it's\n  // irrelevant here!\n    never\n    : // Because of how the implementation works, we need to consider any object\n  // with a `length` prop as potentially \"empty\".\n    EmptyishArbitrary<T, Length>\n  : T extends { size: infer Size extends number }\n    ? // Because of how the implementation works, we need to consider any object\n  // with a `size` prop as potentially \"empty\".\n    EmptyishArbitrary<T, Size>\n    : IsNever<ValueOf<T>> extends true\n      ? // This handles empty objects; by returning T we effectively narrow the\n    // \"else\" branch to `never`.\n      T\n      : HasRequiredKeys<OmitIndexSignature<T>> extends true\n        ? // If the object has required keys it can never be empty, we can use\n      // that fact to narrow the \"if\" branch to `never`.\n        never\n        : HasWritableKeys<T> extends true\n          ? // A mutable object should remain mutable so we can't narrow it\n        // down.\n          Empty<T>\n          : // But immutable objects could be rewritten to prevent any\n            // mutations.\n            { readonly [P in keyof T]: never };\n\n// We use certain props to check for emptiness effectively, but that means we\n// will return those values for any object that has them. Because we don't know\n// anything about those objects we need to be careful about narrowing.\ntype EmptyishArbitrary<T, N>\n  = IsNumericLiteral<N> extends true\n    ? [0] extends [N]\n        ? [N] extends [0]\n            ? // If the prop is a literal 0 the object is and always will be empty\n          // so we can return it to narrow the \"else\" branch as `never`.\n            T\n            : // If it accepts 0, but might accept other values too we need to\n          // consider the object mutable and not narrow it down.\n            Empty<T>\n        : // If the prop will never be 0 we can say it will never be empty and can\n        // return `never` for the \"if\" branch.\n        never\n    : // If the prop isn't a literal value we don't know enough about the object\n  // and should consider it mutable.\n    Empty<T>;\n\n// Overly generic types interfere with our already pretty complex return type.\n// To make our lives easier we can filter them out at the function declaration\n// step and we never need to think about them again.\ntype ShouldNotNarrow<T> = Or<\n  Or<IsAny<T>, IsUnknown<T>>,\n  IsEqual<\n    T,\n    // eslint-disable-next-line ts/no-empty-object-type\n    {}\n  >\n>;\n\n/**\n * A function that checks if the input is empty. Empty is defined as anything\n * exposing a numerical `length`, or `size` property that is equal to `0`. This\n * definition covers strings, arrays, Maps, Sets, plain objects, and custom\n * classes. Additionally, `null` and `undefined` are also considered empty.\n *\n * `number`, `bigint`, `boolean`, `symbol`, and `function` will always return\n * `false`. `RegExp`, `Date`, and weak collections will always return `true`.\n * Classes and Errors are treated as plain objects: if they expose any public\n * property they would be considered non-empty, unless they expose a numerical\n * `length` or `size` property, which defines their emptiness regardless of\n * other properties.\n *\n * This function has *limited* utility at the type level because **negating** it\n * does not yield a useful type in most cases because of TypeScript\n * limitations. Additionally, utilities which accept a narrower input type\n * provide better type-safety on their inputs. In most cases, you should use\n * one of the following functions instead:\n * `isEmpty` - provides better type-safety on inputs by accepting a narrower set of cases.\n * `hasAtLeast` - when the input is just an array/tuple.\n * `isStrictEqual` - when you just need to check for a specific literal value.\n * `isNullish` - when you just care about `null` and `undefined`.\n * `isTruthy` - when you need to also filter `number` and `boolean`.\n *\n * @param data - The variable to check.\n * @signature\n *    isEmptyish(data)\n * @example\n *    isEmptyish(undefined); //=> true\n *    isEmptyish(null); //=> true\n *    isEmptyish(''); //=> true\n *    isEmptyish([]); //=> true\n *    isEmptyish({}); //=> true\n *    isEmptyish(new Map()); //=> true\n *    isEmptyish(new Set()); //=> true\n *    isEmptyish({ a: \"hello\", size: 0 }); //=> true\n *    isEmptyish(/abc/); //=> true\n *    isEmptyish(new Date()); //=> true\n *    isEmptyish(new WeakMap()); //=> true\n *\n *    isEmptyish('test'); //=> false\n *    isEmptyish([1, 2, 3]); //=> false\n *    isEmptyish({ a: \"hello\" }); //=> false\n *    isEmptyish({ length: 1 }); //=> false\n *    isEmptyish(0); //=> false\n *    isEmptyish(true); //=> false\n *    isEmptyish(() => {}); //=> false\n * @category Guard\n */\nexport function isEmptyish<T>(\n  data: ShouldNotNarrow<T> extends true\n    ? never\n    : T | Readonly<Emptyish<NoInfer<T>>>,\n): data is ShouldNotNarrow<T> extends true\n  ? never\n  : T extends unknown\n    ? Emptyish<NoInfer<T>>\n    : never;\nexport function isEmptyish(data: unknown): boolean;\n\nexport function isEmptyish(data: unknown): boolean {\n  // eslint-disable-next-line eqeqeq -- Less code to ship...\n  if (data == undefined || data === '') {\n    // These are the only literal values that are considered emptyish.\n    return true;\n  }\n\n  if (typeof data !== 'object') {\n    // There are no non-object types that could be empty at this point...\n    return false;\n  }\n\n  if ('length' in data && typeof data.length === 'number') {\n    // Arrays and array-likes.\n    return data.length === 0;\n  }\n\n  if ('size' in data && typeof data.size === 'number') {\n    // Maps and Sets.\n    return data.size === 0;\n  }\n\n  // eslint-disable-next-line no-unreachable-loop -- Instead of taking Object.keys just to check its length, which will be inefficient if the object has a lot of keys, we have a backdoor into an iterator of the object's properties via the `for...in` loop.\n  for (const _ in data) {\n    return false;\n  }\n\n  // We can't do a similar optimization for symbol props, so we leave them for\n  // the very last check when the object is practically empty. Assuming that\n  // even if an object has a symbol prop, it probably doesn't have thousands of\n  // them.\n  return Object.getOwnPropertySymbols(data).length === 0;\n}\n"],"mappings":"AAiMA,SAAgB,EAAW,EAAwB,CAEjD,GAAI,GAAQ,MAAa,IAAS,GAEhC,MAAO,GAGT,GAAI,OAAO,GAAS,SAElB,MAAO,GAGT,GAAI,WAAY,GAAQ,OAAO,EAAK,QAAW,SAE7C,OAAO,EAAK,SAAW,EAGzB,GAAI,SAAU,GAAQ,OAAO,EAAK,MAAS,SAEzC,OAAO,EAAK,OAAS,EAIvB,IAAK,IAAM,KAAK,EACd,MAAO,GAOT,OAAO,OAAO,sBAAsB,EAAK,CAAC,SAAW"}
+{"version":3,"file":"is-emptyish.js","names":[],"sources":["../src/is-emptyish.ts"],"sourcesContent":["import type {\n  HasRequiredKeys,\n  IsAny,\n  IsEqual,\n  IsNever,\n  IsNumericLiteral,\n  OmitIndexSignature,\n  Tagged,\n  ValueOf,\n} from 'type-fest';\nimport type { HasWritableKeys } from './internal/types/has-writable-keys';\nimport type { TupleParts } from './internal/types/tuple-parts';\n\n// eslint-disable-next-line ts/no-unused-vars -- we use a non-exported unique symbol to prevent users from faking our return type.\ndeclare const EMPTYISH_BRAND: unique symbol;\n\n// Because our function is a type-predicate and it narrows the input based on\n// the result of our type, we sometimes need a way to \"turn off\" narrowing while\n// still returning the input type. By tagging/branding our return type we stop\n// TypeScript from narrowing it while still allowing it to be used as if it was\n// the input type (because it still extends the type).\ntype Empty<T> = Tagged<T, typeof EMPTYISH_BRAND>;\n\n// The goal of this type is to return the empty \"view\" of the input type. This\n// makes it possible for TypeScript to narrow it precisely.\ntype Emptyish<T>\n  // There are effectively 4 types that can be empty:\n  = | (T extends string ? '' : never)\n    | (T extends object ? EmptyishObjectLike<T> : never)\n    | (T extends null ? null : never)\n    | (T extends undefined ? undefined : never);\n\n// Because of TypeScript's duck-typing, a lot of sub-types of `object` can\n// extend each other so we need to cascade between the different \"kinds\" of\n// objects.\ntype EmptyishObjectLike<T extends object> = T extends ReadonlyArray<unknown>\n  ? EmptyishArray<T>\n  : T extends ReadonlyMap<infer Key, unknown>\n    ? T extends Map<unknown, unknown>\n      ? // Mutable maps should remain mutable so we can't narrow them down.\n      Empty<T>\n      : // But immutable maps could be rewritten to prevent any mutations.\n      ReadonlyMap<Key, never>\n    : T extends ReadonlySet<unknown>\n      ? T extends Set<unknown>\n        ? // Mutable sets should remain mutable so we can't narrow them down.\n        Empty<T>\n        : // But immutable sets could be rewritten to prevent any mutations.\n        ReadonlySet<never>\n      : EmptyishObject<T>;\n\ntype EmptyishArray<T extends ReadonlyArray<unknown>> = T extends readonly []\n  ? // By returning T we effectively narrow the \"else\" branch to `never`.\n  T\n  : TupleParts<T>['required'] extends readonly []\n    ? TupleParts<T>['suffix'] extends readonly []\n      ? T extends Array<unknown>\n        ? // A mutable array should remain mutable so we can't narrow it down.\n        Empty<T>\n        : // But immutable arrays could be rewritten to prevent any mutations.\n        readonly []\n      : // An array with a required prefix or suffix would never be empty, we\n    // can use that fact to narrow the \"if\" branch to `never`.\n      never\n    : never;\n\ntype EmptyishObject<T extends object> = T extends {\n  length: infer Length extends number;\n}\n  ? T extends string\n    ? // When a string is tagged/branded it also extends `object` and also has\n  // a `length` prop so we need to prevent handling it because it's\n  // irrelevant here!\n    never\n    : // Because of how the implementation works, we need to consider any object\n  // with a `length` prop as potentially \"empty\".\n    EmptyishArbitrary<T, Length>\n  : T extends { size: infer Size extends number }\n    ? // Because of how the implementation works, we need to consider any object\n  // with a `size` prop as potentially \"empty\".\n    EmptyishArbitrary<T, Size>\n    : IsNever<ValueOf<T>> extends true\n      ? // This handles empty objects; by returning T we effectively narrow the\n    // \"else\" branch to `never`.\n      T\n      : HasRequiredKeys<OmitIndexSignature<T>> extends true\n        ? // If the object has required keys it can never be empty, we can use\n      // that fact to narrow the \"if\" branch to `never`.\n        never\n        : HasWritableKeys<T> extends true\n          ? // A mutable object should remain mutable so we can't narrow it\n        // down.\n          Empty<T>\n          : // But immutable objects could be rewritten to prevent any\n            // mutations.\n            { readonly [P in keyof T]: never };\n\n// We use certain props to check for emptiness effectively, but that means we\n// will return those values for any object that has them. Because we don't know\n// anything about those objects we need to be careful about narrowing.\ntype EmptyishArbitrary<T, N>\n  = IsNumericLiteral<N> extends true\n    ? [0] extends [N]\n        ? [N] extends [0]\n            ? // If the prop is a literal 0 the object is and always will be empty\n          // so we can return it to narrow the \"else\" branch as `never`.\n            T\n            : // If it accepts 0, but might accept other values too we need to\n          // consider the object mutable and not narrow it down.\n            Empty<T>\n        : // If the prop will never be 0 we can say it will never be empty and can\n        // return `never` for the \"if\" branch.\n        never\n    : // If the prop isn't a literal value we don't know enough about the object\n  // and should consider it mutable.\n    Empty<T>;\n\n// Overly generic types interfere with our already pretty complex return type.\n// To make our lives easier we can filter them out at the function declaration\n// step and we never need to think about them again.\ntype ShouldNotNarrow<T> = unknown extends T\n  ? true\n  : IsAny<T> extends true\n    ? true\n    : IsEqual<\n      T,\n      // eslint-disable-next-line ts/no-empty-object-type\n      {}\n    > extends true\n      ? true\n      : false;\n\n/**\n * A function that checks if the input is empty. Empty is defined as anything\n * exposing a numerical `length`, or `size` property that is equal to `0`. This\n * definition covers strings, arrays, Maps, Sets, plain objects, and custom\n * classes. Additionally, `null` and `undefined` are also considered empty.\n *\n * `number`, `bigint`, `boolean`, `symbol`, and `function` will always return\n * `false`. `RegExp`, `Date`, and weak collections will always return `true`.\n * Classes and Errors are treated as plain objects: if they expose any public\n * property they would be considered non-empty, unless they expose a numerical\n * `length` or `size` property, which defines their emptiness regardless of\n * other properties.\n *\n * This function has *limited* utility at the type level because **negating** it\n * does not yield a useful type in most cases because of TypeScript\n * limitations. Additionally, utilities which accept a narrower input type\n * provide better type-safety on their inputs. In most cases, you should use\n * one of the following functions instead:\n * `isEmpty` - provides better type-safety on inputs by accepting a narrower set of cases.\n * `hasAtLeast` - when the input is just an array/tuple.\n * `isStrictEqual` - when you just need to check for a specific literal value.\n * `isNullish` - when you just care about `null` and `undefined`.\n * `isTruthy` - when you need to also filter `number` and `boolean`.\n *\n * @param data - The variable to check.\n * @signature\n *    isEmptyish(data)\n * @example\n *    isEmptyish(undefined); //=> true\n *    isEmptyish(null); //=> true\n *    isEmptyish(''); //=> true\n *    isEmptyish([]); //=> true\n *    isEmptyish({}); //=> true\n *    isEmptyish(new Map()); //=> true\n *    isEmptyish(new Set()); //=> true\n *    isEmptyish({ a: \"hello\", size: 0 }); //=> true\n *    isEmptyish(/abc/); //=> true\n *    isEmptyish(new Date()); //=> true\n *    isEmptyish(new WeakMap()); //=> true\n *\n *    isEmptyish('test'); //=> false\n *    isEmptyish([1, 2, 3]); //=> false\n *    isEmptyish({ a: \"hello\" }); //=> false\n *    isEmptyish({ length: 1 }); //=> false\n *    isEmptyish(0); //=> false\n *    isEmptyish(true); //=> false\n *    isEmptyish(() => {}); //=> false\n * @category Guard\n */\nexport function isEmptyish<T>(\n  data: ShouldNotNarrow<T> extends true\n    ? never\n    : T | Readonly<Emptyish<NoInfer<T>>>,\n): data is ShouldNotNarrow<T> extends true\n  ? never\n  : T extends unknown\n    ? Emptyish<NoInfer<T>>\n    : never;\nexport function isEmptyish(data: unknown): boolean;\n\nexport function isEmptyish(data: unknown): boolean {\n  // eslint-disable-next-line eqeqeq -- Less code to ship...\n  if (data == undefined || data === '') {\n    // These are the only literal values that are considered emptyish.\n    return true;\n  }\n\n  if (typeof data !== 'object') {\n    // There are no non-object types that could be empty at this point...\n    return false;\n  }\n\n  if ('length' in data && typeof data.length === 'number') {\n    // Arrays and array-likes.\n    return data.length === 0;\n  }\n\n  if ('size' in data && typeof data.size === 'number') {\n    // Maps and Sets.\n    return data.size === 0;\n  }\n\n  // eslint-disable-next-line no-unreachable-loop, no-restricted-syntax -- Instead of taking Object.keys just to check its length, which will be inefficient if the object has a lot of keys, we have a backdoor into an iterator of the object's properties via the `for...in` loop.\n  for (const _ in data) {\n    return false;\n  }\n\n  // We can't do a similar optimization for symbol props, so we leave them for\n  // the very last check when the object is practically empty. Assuming that\n  // even if an object has a symbol prop, it probably doesn't have thousands of\n  // them.\n  return Object.getOwnPropertySymbols(data).length === 0;\n}\n"],"mappings":"AAgMA,SAAgB,EAAW,EAAwB,CAEjD,GAAI,GAAQ,MAAa,IAAS,GAEhC,MAAO,GAGT,GAAI,OAAO,GAAS,SAElB,MAAO,GAGT,GAAI,WAAY,GAAQ,OAAO,EAAK,QAAW,SAE7C,OAAO,EAAK,SAAW,EAGzB,GAAI,SAAU,GAAQ,OAAO,EAAK,MAAS,SAEzC,OAAO,EAAK,OAAS,EAIvB,IAAK,IAAM,KAAK,EACd,MAAO,GAOT,OAAO,OAAO,sBAAsB,CAAI,CAAC,CAAC,SAAW,CACvD"}

package/dist/is-error.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-error.cjs","names":[],"sources":["../src/is-error.ts"],"sourcesContent":["type DefinitelyError<T>\n  = Extract<T, Error> extends never ? Error : Extract<T, Error>;\n/**\n * A function that checks if the passed parameter is an Error and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is an Error, false otherwise.\n * @signature\n *    isError(data)\n * @example\n *    isError(new Error('message')) //=> true\n *    isError('somethingElse') //=> false\n * @category Guard\n */\nexport function isError<T>(data: Error | T): data is DefinitelyError<T> {\n  return data instanceof Error;\n}\n"],"mappings":"mEAcA,SAAgB,EAAW,EAA6C,CACtE,OAAO,aAAgB"}
+{"version":3,"file":"is-error.cjs","names":[],"sources":["../src/is-error.ts"],"sourcesContent":["import type { IsNever } from 'type-fest';\n\ntype DefinitelyError<T>\n  = IsNever<Extract<T, Error>> extends true ? Error : Extract<T, Error>;\n/**\n * A function that checks if the passed parameter is an Error and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is an Error, false otherwise.\n * @signature\n *    isError(data)\n * @example\n *    isError(new Error('message')) //=> true\n *    isError('somethingElse') //=> false\n * @category Guard\n */\nexport function isError<T>(data: Error | T): data is DefinitelyError<T> {\n  return data instanceof Error;\n}\n"],"mappings":"mEAgBA,SAAgB,EAAW,EAA6C,CACtE,OAAO,aAAgB,KACzB"}

package/dist/is-error.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-error.js","names":[],"sources":["../src/is-error.ts"],"sourcesContent":["type DefinitelyError<T>\n  = Extract<T, Error> extends never ? Error : Extract<T, Error>;\n/**\n * A function that checks if the passed parameter is an Error and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is an Error, false otherwise.\n * @signature\n *    isError(data)\n * @example\n *    isError(new Error('message')) //=> true\n *    isError('somethingElse') //=> false\n * @category Guard\n */\nexport function isError<T>(data: Error | T): data is DefinitelyError<T> {\n  return data instanceof Error;\n}\n"],"mappings":"AAcA,SAAgB,EAAW,EAA6C,CACtE,OAAO,aAAgB"}
+{"version":3,"file":"is-error.js","names":[],"sources":["../src/is-error.ts"],"sourcesContent":["import type { IsNever } from 'type-fest';\n\ntype DefinitelyError<T>\n  = IsNever<Extract<T, Error>> extends true ? Error : Extract<T, Error>;\n/**\n * A function that checks if the passed parameter is an Error and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is an Error, false otherwise.\n * @signature\n *    isError(data)\n * @example\n *    isError(new Error('message')) //=> true\n *    isError('somethingElse') //=> false\n * @category Guard\n */\nexport function isError<T>(data: Error | T): data is DefinitelyError<T> {\n  return data instanceof Error;\n}\n"],"mappings":"AAgBA,SAAgB,EAAW,EAA6C,CACtE,OAAO,aAAgB,KACzB"}

package/dist/is-function.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-function.cjs","names":[],"sources":["../src/is-function.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\nimport type { StrictFunction } from './internal/types/strict-function';\n\n/**\n * A function that checks if the passed parameter is a Function and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Function, false otherwise.\n * @signature\n *    isFunction(data)\n * @example\n *    isFunction(() => {}) //=> true\n *    isFunction('somethingElse') //=> false\n * @category Guard\n */\nexport function isFunction<T>(data: StrictFunction | T): data is NarrowedTo<T, StrictFunction> {\n  return typeof data === 'function';\n}\n"],"mappings":"mEAeA,SAAgB,EAAc,EAAiE,CAC7F,OAAO,OAAO,GAAS"}
+{"version":3,"file":"is-function.cjs","names":[],"sources":["../src/is-function.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\nimport type { StrictFunction } from './internal/types/strict-function';\n\n/**\n * A function that checks if the passed parameter is a Function and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Function, false otherwise.\n * @signature\n *    isFunction(data)\n * @example\n *    isFunction(() => {}) //=> true\n *    isFunction('somethingElse') //=> false\n * @category Guard\n */\nexport function isFunction<T>(data: StrictFunction | T): data is NarrowedTo<T, StrictFunction> {\n  return typeof data === 'function';\n}\n"],"mappings":"mEAeA,SAAgB,EAAc,EAAiE,CAC7F,OAAO,OAAO,GAAS,UACzB"}

package/dist/is-function.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-function.js","names":[],"sources":["../src/is-function.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\nimport type { StrictFunction } from './internal/types/strict-function';\n\n/**\n * A function that checks if the passed parameter is a Function and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Function, false otherwise.\n * @signature\n *    isFunction(data)\n * @example\n *    isFunction(() => {}) //=> true\n *    isFunction('somethingElse') //=> false\n * @category Guard\n */\nexport function isFunction<T>(data: StrictFunction | T): data is NarrowedTo<T, StrictFunction> {\n  return typeof data === 'function';\n}\n"],"mappings":"AAeA,SAAgB,EAAc,EAAiE,CAC7F,OAAO,OAAO,GAAS"}
+{"version":3,"file":"is-function.js","names":[],"sources":["../src/is-function.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\nimport type { StrictFunction } from './internal/types/strict-function';\n\n/**\n * A function that checks if the passed parameter is a Function and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Function, false otherwise.\n * @signature\n *    isFunction(data)\n * @example\n *    isFunction(() => {}) //=> true\n *    isFunction('somethingElse') //=> false\n * @category Guard\n */\nexport function isFunction<T>(data: StrictFunction | T): data is NarrowedTo<T, StrictFunction> {\n  return typeof data === 'function';\n}\n"],"mappings":"AAeA,SAAgB,EAAc,EAAiE,CAC7F,OAAO,OAAO,GAAS,UACzB"}

package/dist/is-included-in.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-included-in.cjs","names":[],"sources":["../src/is-included-in.ts"],"sourcesContent":["import type { IsLiteral, IsUnion } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\n\n/**\n * A \"constant\" tuple is a type that has a single runtime value that can fulfil\n * it. This means that it doesn't have any variadic/rest/spread/array parts, and\n * that all it's values are singular (non-union) literals.\n *\n * We use this type to allow narrowing when checking against a set of values\n * defined as a const.\n *\n * @example\n *   type T1 = IsConstantTuple<[\"cat\", \"dog\", 3, true]>; // => true;\n *   type T2 = IsConstantTuple<[\"cat\" | \"dog\"]>; // false;\n *   type T2 = IsConstantTuple<[\"cat\", ...\"cat\"[]]>; // false;\n */\ntype IsConstantTuple<T extends IterableContainer> = T extends readonly []\n  ? true\n  : T extends readonly [infer Head, ...infer Rest]\n    ? IsUnion<Head> extends true\n      ? false\n      : IsConstantTuple<Rest>\n    : false;\n\n/**\n * There is no way to tell Typescript to only narrow the \"accepted\" side of a\n * type-predicate and so in many cases the negated side is also affected, this\n * results in over-narrowing in many cases, breaking typing. For this reason we\n * only want to use the type-predicate variant of `isIncludedIn` when we can\n * assume the result represents the expected types (closely enough). This is not\n * and ideal solution and we will still generate wrong types in some cases (see\n * tests), but it reduces the surface of this problem significantly, while still\n * keeping the utility of `isIncludedIn` for the common cases.\n *\n * TL;DR - The types are narrowable when: T is literal and S is a pure tuple, or\n * when T isn't a literal, but S is.\n *\n * @example\n *   const data = 1 as 1 | 2 | 3;\n *   const container = [] as (1 | 2)[];\n *   if (isIncludedIn(data, container)) {\n *     ... it makes sense to narrow data to `1 | 2` as the value `3` is not part\n *     ... of the typing of container, so will never result in being true.\n *   } else {\n *     ... but it doesn't make sense to narrow the value to 3 here, because 1\n *     ... and 2 are still valid values for data, when container doesn't include\n *     ... them **at runtime**.\n *     ... Typescript narrows the _rejected_ branch based on how it narrowed the\n *     ... _accepted_ clause, and we can't control that; because our input type\n *     ... is `1 | 2 | 3` and the accepted side is `1 | 2`, the rejected side is\n *     ... typed `Exclude<1 | 2 | 3, 1 | 2>`, which is `3`.\n *   }\n * }\n */\ntype IsNarrowable<T, S extends IterableContainer<T>>\n  = IsLiteral<T> extends true\n    ? // When T is literal (i.g. it isn't a primitive type like `string` or\n  // `number`) then the criteria for narrowing is that the container is a\n  // \"pure\" tuple because we *assume* that S represents a constant set of\n  // values, and that it's typing also represents it's runtime content 1-\n  // for-1. If S isn't a pure tuple it means we can't tell from the typing\n  // which of it's values are actually present in runtime so can't use them\n  // to narrow correctly.\n    IsConstantTuple<S>\n    : // When T isn't a literal type but the items in S are we can narrow the\n  // type because it won't affect the negated side (`Exclude<number, 3>`\n  // is still `number`).\n    IsLiteral<S[number]>;\n\n/**\n * Checks if the item is included in the container. This is a wrapper around\n * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the\n * same equality checks that those functions do (which is reference equality,\n * e.g. `===`). In some cases the input's type is also narrowed to the\n * container's item types.\n *\n * Notice that unlike most functions, this function takes a generic item as it's\n * data and **an array** as it's parameter.\n *\n * @param data - The item that is checked.\n * @param container - The items that are checked against.\n * @returns `true` if the item is in the container, or `false` otherwise. In\n * cases the type of `data` is also narrowed down.\n * @signature\n *   isIncludedIn(data, container);\n * @example\n *   isIncludedIn(2, [1, 2, 3]); // => true\n *   isIncludedIn(4, [1, 2, 3]); // => false\n *\n *   const data = \"cat\" as \"cat\" | \"dog\" | \"mouse\";\n *   isIncludedIn(data, [\"cat\", \"dog\"] as const); // true (typed \"cat\" | \"dog\");\n * @dataFirst\n * @category Guard\n */\nexport function isIncludedIn<T, S extends IterableContainer<T>>(\n  data: T,\n  container: IsNarrowable<T, S> extends true ? S : never,\n): data is S[number];\nexport function isIncludedIn<T, S extends T>(\n  data: T,\n  container: IterableContainer<S>,\n): boolean;\n\n/**\n * Checks if the item is included in the container. This is a wrapper around\n * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the\n * same equality checks that those functions do (which is reference equality,\n * e.g. `===`). In some cases the input's type is also narrowed to the\n * container's item types.\n *\n * Notice that unlike most functions, this function takes a generic item as it's\n * data and **an array** as it's parameter.\n *\n * @param container - The items that are checked against.\n * @returns `true` if the item is in the container, or `false` otherwise. In\n * cases the type of `data` is also narrowed down.\n * @signature\n *   isIncludedIn(container)(data);\n * @example\n *   pipe(2, isIncludedIn([1, 2, 3])); // => true\n *   pipe(4, isIncludedIn([1, 2, 3])); // => false\n *\n *   const data = \"cat\" as \"cat\" | \"dog\" | \"mouse\";\n *   pipe(\n *     data,\n *     isIncludedIn([\"cat\", \"dog\"] as const),\n *   ); // => true (typed \"cat\" | \"dog\");\n * @dataLast\n * @category Guard\n */\nexport function isIncludedIn<T, S extends IterableContainer<T>>(\n  container: IsNarrowable<T, S> extends true ? S : never,\n): (data: T) => data is S[number];\nexport function isIncludedIn<T, S extends T>(\n  container: IterableContainer<S>,\n): (data: T) => boolean;\n\nexport function isIncludedIn(\n  dataOrContainer: unknown,\n  container?: ReadonlyArray<unknown>,\n): unknown {\n  if (container === undefined) {\n    // === dataLast ===\n    // We don't use curry here because we can optimize the dataLast case by\n    // memoizing a set and accessing it in O(1) time instead of scanning the\n    // array **each time** (O(n)) each time.\n    const asSet = new Set(dataOrContainer as ReadonlyArray<unknown>);\n    return (data: unknown) => asSet.has(data);\n  }\n\n  // === dataFirst ===\n  return container.includes(dataOrContainer);\n}\n"],"mappings":"mEAyIA,SAAgB,EACd,EACA,EACS,CACT,GAAI,IAAc,IAAA,GAAW,CAK3B,IAAM,EAAQ,IAAI,IAAI,EAA0C,CAChE,MAAQ,IAAkB,EAAM,IAAI,EAAK,CAI3C,OAAO,EAAU,SAAS,EAAgB"}
+{"version":3,"file":"is-included-in.cjs","names":[],"sources":["../src/is-included-in.ts"],"sourcesContent":["import type { IsLiteral, IsUnion } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\n\n/**\n * A \"constant\" tuple is a type that has a single runtime value that can fulfil\n * it. This means that it doesn't have any variadic/rest/spread/array parts, and\n * that all it's values are singular (non-union) literals.\n *\n * We use this type to allow narrowing when checking against a set of values\n * defined as a const.\n *\n * @example\n *   type T1 = IsConstantTuple<[\"cat\", \"dog\", 3, true]>; // => true;\n *   type T2 = IsConstantTuple<[\"cat\" | \"dog\"]>; // false;\n *   type T2 = IsConstantTuple<[\"cat\", ...\"cat\"[]]>; // false;\n */\ntype IsConstantTuple<T extends IterableContainer> = T extends readonly []\n  ? true\n  : T extends readonly [infer Head, ...infer Rest]\n    ? IsUnion<Head> extends true\n      ? false\n      : IsConstantTuple<Rest>\n    : false;\n\n/**\n * There is no way to tell Typescript to only narrow the \"accepted\" side of a\n * type-predicate and so in many cases the negated side is also affected, this\n * results in over-narrowing in many cases, breaking typing. For this reason we\n * only want to use the type-predicate variant of `isIncludedIn` when we can\n * assume the result represents the expected types (closely enough). This is not\n * and ideal solution and we will still generate wrong types in some cases (see\n * tests), but it reduces the surface of this problem significantly, while still\n * keeping the utility of `isIncludedIn` for the common cases.\n *\n * TL;DR - The types are narrowable when: T is literal and S is a pure tuple, or\n * when T isn't a literal, but S is.\n *\n * @example\n *   const data = 1 as 1 | 2 | 3;\n *   const container = [] as (1 | 2)[];\n *   if (isIncludedIn(data, container)) {\n *     ... it makes sense to narrow data to `1 | 2` as the value `3` is not part\n *     ... of the typing of container, so will never result in being true.\n *   } else {\n *     ... but it doesn't make sense to narrow the value to 3 here, because 1\n *     ... and 2 are still valid values for data, when container doesn't include\n *     ... them **at runtime**.\n *     ... Typescript narrows the _rejected_ branch based on how it narrowed the\n *     ... _accepted_ clause, and we can't control that; because our input type\n *     ... is `1 | 2 | 3` and the accepted side is `1 | 2`, the rejected side is\n *     ... typed `Exclude<1 | 2 | 3, 1 | 2>`, which is `3`.\n *   }\n * }\n */\ntype IsNarrowable<T, S extends IterableContainer<T>>\n  = IsLiteral<T> extends true\n    ? // When T is literal (i.g. it isn't a primitive type like `string` or\n  // `number`) then the criteria for narrowing is that the container is a\n  // \"pure\" tuple because we *assume* that S represents a constant set of\n  // values, and that it's typing also represents it's runtime content 1-\n  // for-1. If S isn't a pure tuple it means we can't tell from the typing\n  // which of it's values are actually present in runtime so can't use them\n  // to narrow correctly.\n    IsConstantTuple<S>\n    : // When T isn't a literal type but the items in S are we can narrow the\n  // type because it won't affect the negated side (`Exclude<number, 3>`\n  // is still `number`).\n    IsLiteral<S[number]>;\n\n/**\n * Checks if the item is included in the container. This is a wrapper around\n * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the\n * same equality checks that those functions do (which is reference equality,\n * e.g. `===`). In some cases the input's type is also narrowed to the\n * container's item types.\n *\n * Notice that unlike most functions, this function takes a generic item as it's\n * data and **an array** as it's parameter.\n *\n * @param data - The item that is checked.\n * @param container - The items that are checked against.\n * @returns `true` if the item is in the container, or `false` otherwise. In\n * cases the type of `data` is also narrowed down.\n * @signature\n *   isIncludedIn(data, container);\n * @example\n *   isIncludedIn(2, [1, 2, 3]); // => true\n *   isIncludedIn(4, [1, 2, 3]); // => false\n *\n *   const data = \"cat\" as \"cat\" | \"dog\" | \"mouse\";\n *   isIncludedIn(data, [\"cat\", \"dog\"] as const); // true (typed \"cat\" | \"dog\");\n * @dataFirst\n * @category Guard\n */\nexport function isIncludedIn<T, S extends IterableContainer<T>>(\n  data: T,\n  container: IsNarrowable<T, S> extends true ? S : never,\n): data is S[number];\nexport function isIncludedIn<T, S extends T>(\n  data: T,\n  container: IterableContainer<S>,\n): boolean;\n\n/**\n * Checks if the item is included in the container. This is a wrapper around\n * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the\n * same equality checks that those functions do (which is reference equality,\n * e.g. `===`). In some cases the input's type is also narrowed to the\n * container's item types.\n *\n * Notice that unlike most functions, this function takes a generic item as it's\n * data and **an array** as it's parameter.\n *\n * @param container - The items that are checked against.\n * @returns `true` if the item is in the container, or `false` otherwise. In\n * cases the type of `data` is also narrowed down.\n * @signature\n *   isIncludedIn(container)(data);\n * @example\n *   pipe(2, isIncludedIn([1, 2, 3])); // => true\n *   pipe(4, isIncludedIn([1, 2, 3])); // => false\n *\n *   const data = \"cat\" as \"cat\" | \"dog\" | \"mouse\";\n *   pipe(\n *     data,\n *     isIncludedIn([\"cat\", \"dog\"] as const),\n *   ); // => true (typed \"cat\" | \"dog\");\n * @dataLast\n * @category Guard\n */\nexport function isIncludedIn<T, S extends IterableContainer<T>>(\n  container: IsNarrowable<T, S> extends true ? S : never,\n): (data: T) => data is S[number];\nexport function isIncludedIn<T, S extends T>(\n  container: IterableContainer<S>,\n): (data: T) => boolean;\n\nexport function isIncludedIn(\n  dataOrContainer: unknown,\n  container?: ReadonlyArray<unknown>,\n): unknown {\n  if (container === undefined) {\n    // === dataLast ===\n    // We don't use curry here because we can optimize the dataLast case by\n    // memoizing a set and accessing it in O(1) time instead of scanning the\n    // array **each time** (O(n)) each time.\n    const asSet = new Set(dataOrContainer as ReadonlyArray<unknown>);\n    return (data: unknown) => asSet.has(data);\n  }\n\n  // === dataFirst ===\n  return container.includes(dataOrContainer);\n}\n"],"mappings":"mEAyIA,SAAgB,EACd,EACA,EACS,CACT,GAAI,IAAc,IAAA,GAAW,CAK3B,IAAM,EAAQ,IAAI,IAAI,CAAyC,EAC/D,MAAQ,IAAkB,EAAM,IAAI,CAAI,CAC1C,CAGA,OAAO,EAAU,SAAS,CAAe,CAC3C"}

package/dist/is-included-in.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-included-in.js","names":[],"sources":["../src/is-included-in.ts"],"sourcesContent":["import type { IsLiteral, IsUnion } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\n\n/**\n * A \"constant\" tuple is a type that has a single runtime value that can fulfil\n * it. This means that it doesn't have any variadic/rest/spread/array parts, and\n * that all it's values are singular (non-union) literals.\n *\n * We use this type to allow narrowing when checking against a set of values\n * defined as a const.\n *\n * @example\n *   type T1 = IsConstantTuple<[\"cat\", \"dog\", 3, true]>; // => true;\n *   type T2 = IsConstantTuple<[\"cat\" | \"dog\"]>; // false;\n *   type T2 = IsConstantTuple<[\"cat\", ...\"cat\"[]]>; // false;\n */\ntype IsConstantTuple<T extends IterableContainer> = T extends readonly []\n  ? true\n  : T extends readonly [infer Head, ...infer Rest]\n    ? IsUnion<Head> extends true\n      ? false\n      : IsConstantTuple<Rest>\n    : false;\n\n/**\n * There is no way to tell Typescript to only narrow the \"accepted\" side of a\n * type-predicate and so in many cases the negated side is also affected, this\n * results in over-narrowing in many cases, breaking typing. For this reason we\n * only want to use the type-predicate variant of `isIncludedIn` when we can\n * assume the result represents the expected types (closely enough). This is not\n * and ideal solution and we will still generate wrong types in some cases (see\n * tests), but it reduces the surface of this problem significantly, while still\n * keeping the utility of `isIncludedIn` for the common cases.\n *\n * TL;DR - The types are narrowable when: T is literal and S is a pure tuple, or\n * when T isn't a literal, but S is.\n *\n * @example\n *   const data = 1 as 1 | 2 | 3;\n *   const container = [] as (1 | 2)[];\n *   if (isIncludedIn(data, container)) {\n *     ... it makes sense to narrow data to `1 | 2` as the value `3` is not part\n *     ... of the typing of container, so will never result in being true.\n *   } else {\n *     ... but it doesn't make sense to narrow the value to 3 here, because 1\n *     ... and 2 are still valid values for data, when container doesn't include\n *     ... them **at runtime**.\n *     ... Typescript narrows the _rejected_ branch based on how it narrowed the\n *     ... _accepted_ clause, and we can't control that; because our input type\n *     ... is `1 | 2 | 3` and the accepted side is `1 | 2`, the rejected side is\n *     ... typed `Exclude<1 | 2 | 3, 1 | 2>`, which is `3`.\n *   }\n * }\n */\ntype IsNarrowable<T, S extends IterableContainer<T>>\n  = IsLiteral<T> extends true\n    ? // When T is literal (i.g. it isn't a primitive type like `string` or\n  // `number`) then the criteria for narrowing is that the container is a\n  // \"pure\" tuple because we *assume* that S represents a constant set of\n  // values, and that it's typing also represents it's runtime content 1-\n  // for-1. If S isn't a pure tuple it means we can't tell from the typing\n  // which of it's values are actually present in runtime so can't use them\n  // to narrow correctly.\n    IsConstantTuple<S>\n    : // When T isn't a literal type but the items in S are we can narrow the\n  // type because it won't affect the negated side (`Exclude<number, 3>`\n  // is still `number`).\n    IsLiteral<S[number]>;\n\n/**\n * Checks if the item is included in the container. This is a wrapper around\n * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the\n * same equality checks that those functions do (which is reference equality,\n * e.g. `===`). In some cases the input's type is also narrowed to the\n * container's item types.\n *\n * Notice that unlike most functions, this function takes a generic item as it's\n * data and **an array** as it's parameter.\n *\n * @param data - The item that is checked.\n * @param container - The items that are checked against.\n * @returns `true` if the item is in the container, or `false` otherwise. In\n * cases the type of `data` is also narrowed down.\n * @signature\n *   isIncludedIn(data, container);\n * @example\n *   isIncludedIn(2, [1, 2, 3]); // => true\n *   isIncludedIn(4, [1, 2, 3]); // => false\n *\n *   const data = \"cat\" as \"cat\" | \"dog\" | \"mouse\";\n *   isIncludedIn(data, [\"cat\", \"dog\"] as const); // true (typed \"cat\" | \"dog\");\n * @dataFirst\n * @category Guard\n */\nexport function isIncludedIn<T, S extends IterableContainer<T>>(\n  data: T,\n  container: IsNarrowable<T, S> extends true ? S : never,\n): data is S[number];\nexport function isIncludedIn<T, S extends T>(\n  data: T,\n  container: IterableContainer<S>,\n): boolean;\n\n/**\n * Checks if the item is included in the container. This is a wrapper around\n * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the\n * same equality checks that those functions do (which is reference equality,\n * e.g. `===`). In some cases the input's type is also narrowed to the\n * container's item types.\n *\n * Notice that unlike most functions, this function takes a generic item as it's\n * data and **an array** as it's parameter.\n *\n * @param container - The items that are checked against.\n * @returns `true` if the item is in the container, or `false` otherwise. In\n * cases the type of `data` is also narrowed down.\n * @signature\n *   isIncludedIn(container)(data);\n * @example\n *   pipe(2, isIncludedIn([1, 2, 3])); // => true\n *   pipe(4, isIncludedIn([1, 2, 3])); // => false\n *\n *   const data = \"cat\" as \"cat\" | \"dog\" | \"mouse\";\n *   pipe(\n *     data,\n *     isIncludedIn([\"cat\", \"dog\"] as const),\n *   ); // => true (typed \"cat\" | \"dog\");\n * @dataLast\n * @category Guard\n */\nexport function isIncludedIn<T, S extends IterableContainer<T>>(\n  container: IsNarrowable<T, S> extends true ? S : never,\n): (data: T) => data is S[number];\nexport function isIncludedIn<T, S extends T>(\n  container: IterableContainer<S>,\n): (data: T) => boolean;\n\nexport function isIncludedIn(\n  dataOrContainer: unknown,\n  container?: ReadonlyArray<unknown>,\n): unknown {\n  if (container === undefined) {\n    // === dataLast ===\n    // We don't use curry here because we can optimize the dataLast case by\n    // memoizing a set and accessing it in O(1) time instead of scanning the\n    // array **each time** (O(n)) each time.\n    const asSet = new Set(dataOrContainer as ReadonlyArray<unknown>);\n    return (data: unknown) => asSet.has(data);\n  }\n\n  // === dataFirst ===\n  return container.includes(dataOrContainer);\n}\n"],"mappings":"AAyIA,SAAgB,EACd,EACA,EACS,CACT,GAAI,IAAc,IAAA,GAAW,CAK3B,IAAM,EAAQ,IAAI,IAAI,EAA0C,CAChE,MAAQ,IAAkB,EAAM,IAAI,EAAK,CAI3C,OAAO,EAAU,SAAS,EAAgB"}
+{"version":3,"file":"is-included-in.js","names":[],"sources":["../src/is-included-in.ts"],"sourcesContent":["import type { IsLiteral, IsUnion } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\n\n/**\n * A \"constant\" tuple is a type that has a single runtime value that can fulfil\n * it. This means that it doesn't have any variadic/rest/spread/array parts, and\n * that all it's values are singular (non-union) literals.\n *\n * We use this type to allow narrowing when checking against a set of values\n * defined as a const.\n *\n * @example\n *   type T1 = IsConstantTuple<[\"cat\", \"dog\", 3, true]>; // => true;\n *   type T2 = IsConstantTuple<[\"cat\" | \"dog\"]>; // false;\n *   type T2 = IsConstantTuple<[\"cat\", ...\"cat\"[]]>; // false;\n */\ntype IsConstantTuple<T extends IterableContainer> = T extends readonly []\n  ? true\n  : T extends readonly [infer Head, ...infer Rest]\n    ? IsUnion<Head> extends true\n      ? false\n      : IsConstantTuple<Rest>\n    : false;\n\n/**\n * There is no way to tell Typescript to only narrow the \"accepted\" side of a\n * type-predicate and so in many cases the negated side is also affected, this\n * results in over-narrowing in many cases, breaking typing. For this reason we\n * only want to use the type-predicate variant of `isIncludedIn` when we can\n * assume the result represents the expected types (closely enough). This is not\n * and ideal solution and we will still generate wrong types in some cases (see\n * tests), but it reduces the surface of this problem significantly, while still\n * keeping the utility of `isIncludedIn` for the common cases.\n *\n * TL;DR - The types are narrowable when: T is literal and S is a pure tuple, or\n * when T isn't a literal, but S is.\n *\n * @example\n *   const data = 1 as 1 | 2 | 3;\n *   const container = [] as (1 | 2)[];\n *   if (isIncludedIn(data, container)) {\n *     ... it makes sense to narrow data to `1 | 2` as the value `3` is not part\n *     ... of the typing of container, so will never result in being true.\n *   } else {\n *     ... but it doesn't make sense to narrow the value to 3 here, because 1\n *     ... and 2 are still valid values for data, when container doesn't include\n *     ... them **at runtime**.\n *     ... Typescript narrows the _rejected_ branch based on how it narrowed the\n *     ... _accepted_ clause, and we can't control that; because our input type\n *     ... is `1 | 2 | 3` and the accepted side is `1 | 2`, the rejected side is\n *     ... typed `Exclude<1 | 2 | 3, 1 | 2>`, which is `3`.\n *   }\n * }\n */\ntype IsNarrowable<T, S extends IterableContainer<T>>\n  = IsLiteral<T> extends true\n    ? // When T is literal (i.g. it isn't a primitive type like `string` or\n  // `number`) then the criteria for narrowing is that the container is a\n  // \"pure\" tuple because we *assume* that S represents a constant set of\n  // values, and that it's typing also represents it's runtime content 1-\n  // for-1. If S isn't a pure tuple it means we can't tell from the typing\n  // which of it's values are actually present in runtime so can't use them\n  // to narrow correctly.\n    IsConstantTuple<S>\n    : // When T isn't a literal type but the items in S are we can narrow the\n  // type because it won't affect the negated side (`Exclude<number, 3>`\n  // is still `number`).\n    IsLiteral<S[number]>;\n\n/**\n * Checks if the item is included in the container. This is a wrapper around\n * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the\n * same equality checks that those functions do (which is reference equality,\n * e.g. `===`). In some cases the input's type is also narrowed to the\n * container's item types.\n *\n * Notice that unlike most functions, this function takes a generic item as it's\n * data and **an array** as it's parameter.\n *\n * @param data - The item that is checked.\n * @param container - The items that are checked against.\n * @returns `true` if the item is in the container, or `false` otherwise. In\n * cases the type of `data` is also narrowed down.\n * @signature\n *   isIncludedIn(data, container);\n * @example\n *   isIncludedIn(2, [1, 2, 3]); // => true\n *   isIncludedIn(4, [1, 2, 3]); // => false\n *\n *   const data = \"cat\" as \"cat\" | \"dog\" | \"mouse\";\n *   isIncludedIn(data, [\"cat\", \"dog\"] as const); // true (typed \"cat\" | \"dog\");\n * @dataFirst\n * @category Guard\n */\nexport function isIncludedIn<T, S extends IterableContainer<T>>(\n  data: T,\n  container: IsNarrowable<T, S> extends true ? S : never,\n): data is S[number];\nexport function isIncludedIn<T, S extends T>(\n  data: T,\n  container: IterableContainer<S>,\n): boolean;\n\n/**\n * Checks if the item is included in the container. This is a wrapper around\n * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the\n * same equality checks that those functions do (which is reference equality,\n * e.g. `===`). In some cases the input's type is also narrowed to the\n * container's item types.\n *\n * Notice that unlike most functions, this function takes a generic item as it's\n * data and **an array** as it's parameter.\n *\n * @param container - The items that are checked against.\n * @returns `true` if the item is in the container, or `false` otherwise. In\n * cases the type of `data` is also narrowed down.\n * @signature\n *   isIncludedIn(container)(data);\n * @example\n *   pipe(2, isIncludedIn([1, 2, 3])); // => true\n *   pipe(4, isIncludedIn([1, 2, 3])); // => false\n *\n *   const data = \"cat\" as \"cat\" | \"dog\" | \"mouse\";\n *   pipe(\n *     data,\n *     isIncludedIn([\"cat\", \"dog\"] as const),\n *   ); // => true (typed \"cat\" | \"dog\");\n * @dataLast\n * @category Guard\n */\nexport function isIncludedIn<T, S extends IterableContainer<T>>(\n  container: IsNarrowable<T, S> extends true ? S : never,\n): (data: T) => data is S[number];\nexport function isIncludedIn<T, S extends T>(\n  container: IterableContainer<S>,\n): (data: T) => boolean;\n\nexport function isIncludedIn(\n  dataOrContainer: unknown,\n  container?: ReadonlyArray<unknown>,\n): unknown {\n  if (container === undefined) {\n    // === dataLast ===\n    // We don't use curry here because we can optimize the dataLast case by\n    // memoizing a set and accessing it in O(1) time instead of scanning the\n    // array **each time** (O(n)) each time.\n    const asSet = new Set(dataOrContainer as ReadonlyArray<unknown>);\n    return (data: unknown) => asSet.has(data);\n  }\n\n  // === dataFirst ===\n  return container.includes(dataOrContainer);\n}\n"],"mappings":"AAyIA,SAAgB,EACd,EACA,EACS,CACT,GAAI,IAAc,IAAA,GAAW,CAK3B,IAAM,EAAQ,IAAI,IAAI,CAAyC,EAC/D,MAAQ,IAAkB,EAAM,IAAI,CAAI,CAC1C,CAGA,OAAO,EAAU,SAAS,CAAe,CAC3C"}

package/dist/is-non-null.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-null.cjs","names":[],"sources":["../src/is-non-null.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is not `null` and narrows its type accordingly.\n * Notice that `undefined` is not null!\n *\n * @param data - The variable to check.\n * @returns True if the passed input is defined, false otherwise.\n * @signature\n *    isNonNull(data)\n * @example\n *    isNonNull('string') //=> true\n *    isNonNull(null) //=> false\n *    isNonNull(undefined) //=> true\n * @category Guard\n */\nexport function isNonNull<T>(data: T | null): data is T {\n  return data !== null;\n}\n"],"mappings":"mEAcA,SAAgB,EAAa,EAA2B,CACtD,OAAO,IAAS"}
+{"version":3,"file":"is-non-null.cjs","names":[],"sources":["../src/is-non-null.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is not `null` and narrows its type accordingly.\n * Notice that `undefined` is not null!\n *\n * @param data - The variable to check.\n * @returns True if the passed input is defined, false otherwise.\n * @signature\n *    isNonNull(data)\n * @example\n *    isNonNull('string') //=> true\n *    isNonNull(null) //=> false\n *    isNonNull(undefined) //=> true\n * @category Guard\n */\nexport function isNonNull<T>(data: T | null): data is T {\n  return data !== null;\n}\n"],"mappings":"mEAcA,SAAgB,EAAa,EAA2B,CACtD,OAAO,IAAS,IAClB"}

package/dist/is-non-null.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-null.js","names":[],"sources":["../src/is-non-null.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is not `null` and narrows its type accordingly.\n * Notice that `undefined` is not null!\n *\n * @param data - The variable to check.\n * @returns True if the passed input is defined, false otherwise.\n * @signature\n *    isNonNull(data)\n * @example\n *    isNonNull('string') //=> true\n *    isNonNull(null) //=> false\n *    isNonNull(undefined) //=> true\n * @category Guard\n */\nexport function isNonNull<T>(data: T | null): data is T {\n  return data !== null;\n}\n"],"mappings":"AAcA,SAAgB,EAAa,EAA2B,CACtD,OAAO,IAAS"}
+{"version":3,"file":"is-non-null.js","names":[],"sources":["../src/is-non-null.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is not `null` and narrows its type accordingly.\n * Notice that `undefined` is not null!\n *\n * @param data - The variable to check.\n * @returns True if the passed input is defined, false otherwise.\n * @signature\n *    isNonNull(data)\n * @example\n *    isNonNull('string') //=> true\n *    isNonNull(null) //=> false\n *    isNonNull(undefined) //=> true\n * @category Guard\n */\nexport function isNonNull<T>(data: T | null): data is T {\n  return data !== null;\n}\n"],"mappings":"AAcA,SAAgB,EAAa,EAA2B,CACtD,OAAO,IAAS,IAClB"}

package/dist/is-non-nullish.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-nullish.cjs","names":[],"sources":["../src/is-non-nullish.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is defined *AND* isn't `null`\n * and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is defined and isn't `null`, false\n * otherwise.\n * @signature\n *    isNonNullish(data)\n * @example\n *    isNonNullish('string') //=> true\n *    isNonNullish(null) //=> false\n *    isNonNullish(undefined) //=> false\n * @category Guard\n */\nexport function isNonNullish<T>(data: T): data is NonNullable<T> {\n  return data !== undefined && data !== null;\n}\n"],"mappings":"mEAeA,SAAgB,EAAgB,EAAiC,CAC/D,OAAO,GAA+B"}
+{"version":3,"file":"is-non-nullish.cjs","names":[],"sources":["../src/is-non-nullish.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is defined *AND* isn't `null`\n * and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is defined and isn't `null`, false\n * otherwise.\n * @signature\n *    isNonNullish(data)\n * @example\n *    isNonNullish('string') //=> true\n *    isNonNullish(null) //=> false\n *    isNonNullish(undefined) //=> false\n * @category Guard\n */\nexport function isNonNullish<T>(data: T): data is NonNullable<T> {\n  return data !== undefined && data !== null;\n}\n"],"mappings":"mEAeA,SAAgB,EAAgB,EAAiC,CAC/D,OAAO,GAA+B,IACxC"}

package/dist/is-non-nullish.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-nullish.js","names":[],"sources":["../src/is-non-nullish.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is defined *AND* isn't `null`\n * and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is defined and isn't `null`, false\n * otherwise.\n * @signature\n *    isNonNullish(data)\n * @example\n *    isNonNullish('string') //=> true\n *    isNonNullish(null) //=> false\n *    isNonNullish(undefined) //=> false\n * @category Guard\n */\nexport function isNonNullish<T>(data: T): data is NonNullable<T> {\n  return data !== undefined && data !== null;\n}\n"],"mappings":"AAeA,SAAgB,EAAgB,EAAiC,CAC/D,OAAO,GAA+B"}
+{"version":3,"file":"is-non-nullish.js","names":[],"sources":["../src/is-non-nullish.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is defined *AND* isn't `null`\n * and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is defined and isn't `null`, false\n * otherwise.\n * @signature\n *    isNonNullish(data)\n * @example\n *    isNonNullish('string') //=> true\n *    isNonNullish(null) //=> false\n *    isNonNullish(undefined) //=> false\n * @category Guard\n */\nexport function isNonNullish<T>(data: T): data is NonNullable<T> {\n  return data !== undefined && data !== null;\n}\n"],"mappings":"AAeA,SAAgB,EAAgB,EAAiC,CAC/D,OAAO,GAA+B,IACxC"}

package/dist/is-not.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-not.cjs","names":[],"sources":["../src/is-not.ts"],"sourcesContent":["/**\n * A function that takes a guard function as predicate and returns a guard that negates it.\n *\n * @param predicate - The guard function to negate.\n * @returns Function A guard function.\n * @signature\n *    isNot(isTruthy)(data)\n * @example\n *    isNot(isTruthy)(false) //=> true\n *    isNot(isTruthy)(true) //=> false\n * @dataLast\n * @category Guard\n */\nexport function isNot<T, S extends T>(\n  predicate: (data: T) => data is S,\n): (data: T) => data is Exclude<T, S>;\nexport function isNot<T>(predicate: (data: T) => boolean): (data: T) => boolean;\n\nexport function isNot<T>(predicate: (data: T) => boolean) {\n  return (data: T): boolean => !predicate(data);\n}\n"],"mappings":"mEAkBA,SAAgB,EAAS,EAAiC,CACxD,MAAQ,IAAqB,CAAC,EAAU,EAAK"}
+{"version":3,"file":"is-not.cjs","names":[],"sources":["../src/is-not.ts"],"sourcesContent":["/**\n * A function that takes a guard function as predicate and returns a guard that negates it.\n *\n * @param predicate - The guard function to negate.\n * @returns Function A guard function.\n * @signature\n *    isNot(isTruthy)(data)\n * @example\n *    isNot(isTruthy)(false) //=> true\n *    isNot(isTruthy)(true) //=> false\n * @dataLast\n * @category Guard\n */\nexport function isNot<T, S extends T>(\n  predicate: (data: T) => data is S,\n): (data: T) => data is Exclude<T, S>;\nexport function isNot<T>(predicate: (data: T) => boolean): (data: T) => boolean;\n\nexport function isNot<T>(predicate: (data: T) => boolean) {\n  return (data: T): boolean => !predicate(data);\n}\n"],"mappings":"mEAkBA,SAAgB,EAAS,EAAiC,CACxD,MAAQ,IAAqB,CAAC,EAAU,CAAI,CAC9C"}

package/dist/is-not.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-not.js","names":[],"sources":["../src/is-not.ts"],"sourcesContent":["/**\n * A function that takes a guard function as predicate and returns a guard that negates it.\n *\n * @param predicate - The guard function to negate.\n * @returns Function A guard function.\n * @signature\n *    isNot(isTruthy)(data)\n * @example\n *    isNot(isTruthy)(false) //=> true\n *    isNot(isTruthy)(true) //=> false\n * @dataLast\n * @category Guard\n */\nexport function isNot<T, S extends T>(\n  predicate: (data: T) => data is S,\n): (data: T) => data is Exclude<T, S>;\nexport function isNot<T>(predicate: (data: T) => boolean): (data: T) => boolean;\n\nexport function isNot<T>(predicate: (data: T) => boolean) {\n  return (data: T): boolean => !predicate(data);\n}\n"],"mappings":"AAkBA,SAAgB,EAAS,EAAiC,CACxD,MAAQ,IAAqB,CAAC,EAAU,EAAK"}
+{"version":3,"file":"is-not.js","names":[],"sources":["../src/is-not.ts"],"sourcesContent":["/**\n * A function that takes a guard function as predicate and returns a guard that negates it.\n *\n * @param predicate - The guard function to negate.\n * @returns Function A guard function.\n * @signature\n *    isNot(isTruthy)(data)\n * @example\n *    isNot(isTruthy)(false) //=> true\n *    isNot(isTruthy)(true) //=> false\n * @dataLast\n * @category Guard\n */\nexport function isNot<T, S extends T>(\n  predicate: (data: T) => data is S,\n): (data: T) => data is Exclude<T, S>;\nexport function isNot<T>(predicate: (data: T) => boolean): (data: T) => boolean;\n\nexport function isNot<T>(predicate: (data: T) => boolean) {\n  return (data: T): boolean => !predicate(data);\n}\n"],"mappings":"AAkBA,SAAgB,EAAS,EAAiC,CACxD,MAAQ,IAAqB,CAAC,EAAU,CAAI,CAC9C"}

package/dist/is-nullish.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-nullish.cjs","names":[],"sources":["../src/is-nullish.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is either `null` or\n * `undefined` and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is either `null` or `undefined`, false\n * otherwise.\n * @signature\n *    isNullish(data)\n * @example\n *    isNullish(undefined) //=> true\n *    isNullish(null) //=> true\n *    isNullish('somethingElse') //=> false\n * @category Guard\n */\nexport function isNullish<T>(\n  data: T | null | undefined,\n): data is NarrowedTo<T, null | undefined> {\n  return data === null || data === undefined;\n}\n"],"mappings":"mEAiBA,SAAgB,EACd,EACyC,CACzC,OAAO,GAAS"}
+{"version":3,"file":"is-nullish.cjs","names":[],"sources":["../src/is-nullish.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is either `null` or\n * `undefined` and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is either `null` or `undefined`, false\n * otherwise.\n * @signature\n *    isNullish(data)\n * @example\n *    isNullish(undefined) //=> true\n *    isNullish(null) //=> true\n *    isNullish('somethingElse') //=> false\n * @category Guard\n */\nexport function isNullish<T>(\n  data: T | null | undefined,\n): data is NarrowedTo<T, null | undefined> {\n  return data === null || data === undefined;\n}\n"],"mappings":"mEAiBA,SAAgB,EACd,EACyC,CACzC,OAAO,GAAS,IAClB"}

package/dist/is-nullish.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-nullish.js","names":[],"sources":["../src/is-nullish.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is either `null` or\n * `undefined` and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is either `null` or `undefined`, false\n * otherwise.\n * @signature\n *    isNullish(data)\n * @example\n *    isNullish(undefined) //=> true\n *    isNullish(null) //=> true\n *    isNullish('somethingElse') //=> false\n * @category Guard\n */\nexport function isNullish<T>(\n  data: T | null | undefined,\n): data is NarrowedTo<T, null | undefined> {\n  return data === null || data === undefined;\n}\n"],"mappings":"AAiBA,SAAgB,EACd,EACyC,CACzC,OAAO,GAAS"}
+{"version":3,"file":"is-nullish.js","names":[],"sources":["../src/is-nullish.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is either `null` or\n * `undefined` and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is either `null` or `undefined`, false\n * otherwise.\n * @signature\n *    isNullish(data)\n * @example\n *    isNullish(undefined) //=> true\n *    isNullish(null) //=> true\n *    isNullish('somethingElse') //=> false\n * @category Guard\n */\nexport function isNullish<T>(\n  data: T | null | undefined,\n): data is NarrowedTo<T, null | undefined> {\n  return data === null || data === undefined;\n}\n"],"mappings":"AAiBA,SAAgB,EACd,EACyC,CACzC,OAAO,GAAS,IAClB"}

package/dist/is-number.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-number.cjs","names":[],"sources":["../src/is-number.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a number and narrows its\n * type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a number, false otherwise.\n * @signature\n *    isNumber(data)\n * @example\n *    isNumber(1); // => true\n *    isNumber(1n); // => false\n *    isNumber('notANumber'); // => false\n * @category Guard\n */\nexport function isNumber<T>(data: T | number): data is NarrowedTo<T, number> {\n  return typeof data === 'number' && !Number.isNaN(data);\n}\n"],"mappings":"mEAgBA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,UAAY,CAAC,OAAO,MAAM,EAAK"}
+{"version":3,"file":"is-number.cjs","names":[],"sources":["../src/is-number.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a number and narrows its\n * type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a number, false otherwise.\n * @signature\n *    isNumber(data)\n * @example\n *    isNumber(1); // => true\n *    isNumber(1n); // => false\n *    isNumber('notANumber'); // => false\n * @category Guard\n */\nexport function isNumber<T>(data: T | number): data is NarrowedTo<T, number> {\n  return typeof data === 'number' && !Number.isNaN(data);\n}\n"],"mappings":"mEAgBA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,UAAY,CAAC,OAAO,MAAM,CAAI,CACvD"}

package/dist/is-number.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-number.js","names":[],"sources":["../src/is-number.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a number and narrows its\n * type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a number, false otherwise.\n * @signature\n *    isNumber(data)\n * @example\n *    isNumber(1); // => true\n *    isNumber(1n); // => false\n *    isNumber('notANumber'); // => false\n * @category Guard\n */\nexport function isNumber<T>(data: T | number): data is NarrowedTo<T, number> {\n  return typeof data === 'number' && !Number.isNaN(data);\n}\n"],"mappings":"AAgBA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,UAAY,CAAC,OAAO,MAAM,EAAK"}
+{"version":3,"file":"is-number.js","names":[],"sources":["../src/is-number.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a number and narrows its\n * type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a number, false otherwise.\n * @signature\n *    isNumber(data)\n * @example\n *    isNumber(1); // => true\n *    isNumber(1n); // => false\n *    isNumber('notANumber'); // => false\n * @category Guard\n */\nexport function isNumber<T>(data: T | number): data is NarrowedTo<T, number> {\n  return typeof data === 'number' && !Number.isNaN(data);\n}\n"],"mappings":"AAgBA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,UAAY,CAAC,OAAO,MAAM,CAAI,CACvD"}

package/dist/is-object-type.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-object-type.cjs","names":[],"sources":["../src/is-object-type.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if the given parameter is of type `\"object\"` via `typeof`, excluding `null`.\n *\n * 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.\n *\n * 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`.\n *\n * @param data - The variable to be checked for being an object type.\n * @returns The input type, narrowed to only objects.\n * @signature\n *    isObjectType(data)\n * @example\n *    // true\n *    isObjectType({}) //=> true\n *    isObjectType([]) //=> true\n *    isObjectType(Promise.resolve(\"something\")) //=> true\n *    isObjectType(new Date()) //=> true\n *    isObjectType(new Error(\"error\")) //=> true\n *\n *    // false\n *    isObjectType('somethingElse') //=> false\n *    isObjectType(null) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isObjectType<T>(\n  data: T | object,\n): data is NarrowedTo<T, object> {\n  return typeof data === 'object' && data !== null;\n}\n"],"mappings":"mEA2BA,SAAgB,EACd,EAC+B,CAC/B,OAAO,OAAO,GAAS,YAAY"}
+{"version":3,"file":"is-object-type.cjs","names":[],"sources":["../src/is-object-type.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if the given parameter is of type `\"object\"` via `typeof`, excluding `null`.\n *\n * 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.\n *\n * 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`.\n *\n * @param data - The variable to be checked for being an object type.\n * @returns The input type, narrowed to only objects.\n * @signature\n *    isObjectType(data)\n * @example\n *    // true\n *    isObjectType({}) //=> true\n *    isObjectType([]) //=> true\n *    isObjectType(Promise.resolve(\"something\")) //=> true\n *    isObjectType(new Date()) //=> true\n *    isObjectType(new Error(\"error\")) //=> true\n *\n *    // false\n *    isObjectType('somethingElse') //=> false\n *    isObjectType(null) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isObjectType<T>(\n  data: T | object,\n): data is NarrowedTo<T, object> {\n  return typeof data === 'object' && data !== null;\n}\n"],"mappings":"mEA2BA,SAAgB,EACd,EAC+B,CAC/B,OAAO,OAAO,GAAS,YAAY,CACrC"}

package/dist/is-object-type.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-object-type.js","names":[],"sources":["../src/is-object-type.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if the given parameter is of type `\"object\"` via `typeof`, excluding `null`.\n *\n * 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.\n *\n * 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`.\n *\n * @param data - The variable to be checked for being an object type.\n * @returns The input type, narrowed to only objects.\n * @signature\n *    isObjectType(data)\n * @example\n *    // true\n *    isObjectType({}) //=> true\n *    isObjectType([]) //=> true\n *    isObjectType(Promise.resolve(\"something\")) //=> true\n *    isObjectType(new Date()) //=> true\n *    isObjectType(new Error(\"error\")) //=> true\n *\n *    // false\n *    isObjectType('somethingElse') //=> false\n *    isObjectType(null) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isObjectType<T>(\n  data: T | object,\n): data is NarrowedTo<T, object> {\n  return typeof data === 'object' && data !== null;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EAC+B,CAC/B,OAAO,OAAO,GAAS,YAAY"}
+{"version":3,"file":"is-object-type.js","names":[],"sources":["../src/is-object-type.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if the given parameter is of type `\"object\"` via `typeof`, excluding `null`.\n *\n * 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.\n *\n * 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`.\n *\n * @param data - The variable to be checked for being an object type.\n * @returns The input type, narrowed to only objects.\n * @signature\n *    isObjectType(data)\n * @example\n *    // true\n *    isObjectType({}) //=> true\n *    isObjectType([]) //=> true\n *    isObjectType(Promise.resolve(\"something\")) //=> true\n *    isObjectType(new Date()) //=> true\n *    isObjectType(new Error(\"error\")) //=> true\n *\n *    // false\n *    isObjectType('somethingElse') //=> false\n *    isObjectType(null) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isObjectType<T>(\n  data: T | object,\n): data is NarrowedTo<T, object> {\n  return typeof data === 'object' && data !== null;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EAC+B,CAC/B,OAAO,OAAO,GAAS,YAAY,CACrC"}

package/dist/is-plain-object.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-plain-object.cjs","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if `data` is a \"plain\" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.\n *\n * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `\"object\"` by JavaScript's `typeof`.\n *\n * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.\n *\n * @param data - The variable to check.\n * @returns The input type, narrowed to only plain objects.\n * @signature\n *    isPlainObject(data)\n * @example\n *    // true\n *    isPlainObject({}) //=> true\n *    isPlainObject({ a: 123 }) //=> true\n *\n *    // false\n *    isPlainObject([]) //=> false\n *    isPlainObject(Promise.resolve(\"something\")) //=> false\n *    isPlainObject(new Date()) //=> false\n *    isPlainObject(new Error(\"error\")) //=> false\n *    isPlainObject('somethingElse') //=> false\n *    isPlainObject(null) //=> false\n * @category Guard\n */\nexport function isPlainObject<T>(\n  data: Readonly<Record<PropertyKey, unknown>> | T,\n): data is NarrowedTo<T, Record<PropertyKey, unknown>> {\n  if (typeof data !== 'object' || data == null) {\n    return false;\n  }\n\n  const proto = Object.getPrototypeOf(data);\n  return proto === null || proto === Object.prototype;\n}\n"],"mappings":"mEA2BA,SAAgB,EACd,EACqD,CACrD,GAAI,OAAO,GAAS,WAAY,EAC9B,MAAO,GAGT,IAAM,EAAQ,OAAO,eAAe,EAAK,CACzC,OAAO,IAAU,MAAQ,IAAU,OAAO"}
+{"version":3,"file":"is-plain-object.cjs","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if `data` is a \"plain\" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.\n *\n * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `\"object\"` by JavaScript's `typeof`.\n *\n * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.\n *\n * @param data - The variable to check.\n * @returns The input type, narrowed to only plain objects.\n * @signature\n *    isPlainObject(data)\n * @example\n *    // true\n *    isPlainObject({}) //=> true\n *    isPlainObject({ a: 123 }) //=> true\n *\n *    // false\n *    isPlainObject([]) //=> false\n *    isPlainObject(Promise.resolve(\"something\")) //=> false\n *    isPlainObject(new Date()) //=> false\n *    isPlainObject(new Error(\"error\")) //=> false\n *    isPlainObject('somethingElse') //=> false\n *    isPlainObject(null) //=> false\n * @category Guard\n */\nexport function isPlainObject<T>(\n  data: Readonly<Record<PropertyKey, unknown>> | T,\n): data is NarrowedTo<T, Record<PropertyKey, unknown>> {\n  if (typeof data !== 'object' || data == null) {\n    return false;\n  }\n\n  const proto = Object.getPrototypeOf(data);\n  return proto === null || proto === Object.prototype;\n}\n"],"mappings":"mEA2BA,SAAgB,EACd,EACqD,CACrD,GAAI,OAAO,GAAS,WAAY,EAC9B,MAAO,GAGT,IAAM,EAAQ,OAAO,eAAe,CAAI,EACxC,OAAO,IAAU,MAAQ,IAAU,OAAO,SAC5C"}

package/dist/is-plain-object.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-plain-object.js","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if `data` is a \"plain\" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.\n *\n * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `\"object\"` by JavaScript's `typeof`.\n *\n * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.\n *\n * @param data - The variable to check.\n * @returns The input type, narrowed to only plain objects.\n * @signature\n *    isPlainObject(data)\n * @example\n *    // true\n *    isPlainObject({}) //=> true\n *    isPlainObject({ a: 123 }) //=> true\n *\n *    // false\n *    isPlainObject([]) //=> false\n *    isPlainObject(Promise.resolve(\"something\")) //=> false\n *    isPlainObject(new Date()) //=> false\n *    isPlainObject(new Error(\"error\")) //=> false\n *    isPlainObject('somethingElse') //=> false\n *    isPlainObject(null) //=> false\n * @category Guard\n */\nexport function isPlainObject<T>(\n  data: Readonly<Record<PropertyKey, unknown>> | T,\n): data is NarrowedTo<T, Record<PropertyKey, unknown>> {\n  if (typeof data !== 'object' || data == null) {\n    return false;\n  }\n\n  const proto = Object.getPrototypeOf(data);\n  return proto === null || proto === Object.prototype;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EACqD,CACrD,GAAI,OAAO,GAAS,WAAY,EAC9B,MAAO,GAGT,IAAM,EAAQ,OAAO,eAAe,EAAK,CACzC,OAAO,IAAU,MAAQ,IAAU,OAAO"}
+{"version":3,"file":"is-plain-object.js","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if `data` is a \"plain\" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.\n *\n * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `\"object\"` by JavaScript's `typeof`.\n *\n * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.\n *\n * @param data - The variable to check.\n * @returns The input type, narrowed to only plain objects.\n * @signature\n *    isPlainObject(data)\n * @example\n *    // true\n *    isPlainObject({}) //=> true\n *    isPlainObject({ a: 123 }) //=> true\n *\n *    // false\n *    isPlainObject([]) //=> false\n *    isPlainObject(Promise.resolve(\"something\")) //=> false\n *    isPlainObject(new Date()) //=> false\n *    isPlainObject(new Error(\"error\")) //=> false\n *    isPlainObject('somethingElse') //=> false\n *    isPlainObject(null) //=> false\n * @category Guard\n */\nexport function isPlainObject<T>(\n  data: Readonly<Record<PropertyKey, unknown>> | T,\n): data is NarrowedTo<T, Record<PropertyKey, unknown>> {\n  if (typeof data !== 'object' || data == null) {\n    return false;\n  }\n\n  const proto = Object.getPrototypeOf(data);\n  return proto === null || proto === Object.prototype;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EACqD,CACrD,GAAI,OAAO,GAAS,WAAY,EAC9B,MAAO,GAGT,IAAM,EAAQ,OAAO,eAAe,CAAI,EACxC,OAAO,IAAU,MAAQ,IAAU,OAAO,SAC5C"}

package/dist/is-promise.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-promise.cjs","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a Promise and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Promise, false otherwise.\n * @signature\n *    isPromise(data)\n * @example\n *    isPromise(Promise.resolve(5)) //=> true\n *    isPromise(Promise.reject(5)) //=> true\n *    isPromise('somethingElse') //=> false\n * @category Guard\n */\nexport function isPromise<T>(\n  data: Readonly<PromiseLike<unknown>> | T,\n): data is NarrowedTo<T, PromiseLike<unknown>> {\n  return data instanceof Promise;\n}\n"],"mappings":"mEAeA,SAAgB,EACd,EAC6C,CAC7C,OAAO,aAAgB"}
+{"version":3,"file":"is-promise.cjs","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a Promise and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Promise, false otherwise.\n * @signature\n *    isPromise(data)\n * @example\n *    isPromise(Promise.resolve(5)) //=> true\n *    isPromise(Promise.reject(5)) //=> true\n *    isPromise('somethingElse') //=> false\n * @category Guard\n */\nexport function isPromise<T>(\n  data: Readonly<PromiseLike<unknown>> | T,\n): data is NarrowedTo<T, PromiseLike<unknown>> {\n  return data instanceof Promise;\n}\n"],"mappings":"mEAeA,SAAgB,EACd,EAC6C,CAC7C,OAAO,aAAgB,OACzB"}

package/dist/is-promise.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-promise.js","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a Promise and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Promise, false otherwise.\n * @signature\n *    isPromise(data)\n * @example\n *    isPromise(Promise.resolve(5)) //=> true\n *    isPromise(Promise.reject(5)) //=> true\n *    isPromise('somethingElse') //=> false\n * @category Guard\n */\nexport function isPromise<T>(\n  data: Readonly<PromiseLike<unknown>> | T,\n): data is NarrowedTo<T, PromiseLike<unknown>> {\n  return data instanceof Promise;\n}\n"],"mappings":"AAeA,SAAgB,EACd,EAC6C,CAC7C,OAAO,aAAgB"}
+{"version":3,"file":"is-promise.js","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a Promise and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Promise, false otherwise.\n * @signature\n *    isPromise(data)\n * @example\n *    isPromise(Promise.resolve(5)) //=> true\n *    isPromise(Promise.reject(5)) //=> true\n *    isPromise('somethingElse') //=> false\n * @category Guard\n */\nexport function isPromise<T>(\n  data: Readonly<PromiseLike<unknown>> | T,\n): data is NarrowedTo<T, PromiseLike<unknown>> {\n  return data instanceof Promise;\n}\n"],"mappings":"AAeA,SAAgB,EACd,EAC6C,CAC7C,OAAO,aAAgB,OACzB"}

package/dist/is-shallow-equal.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;if(e instanceof Map&&t instanceof Map)return r(e,t);if(e instanceof Set&&t instanceof Set)return i(e,t);let n=Object.keys(e);if(n.length!==Object.keys(t).length)return!1;for(let r of n){if(!Object.hasOwn(t,r))return!1;let{[r]:n}=e,{[r]:i}=t;if(n!==i||!Object.is(n,i))return!1}return!0}function r(e,t){if(e.size!==t.size)return!1;for(let[n,r]of e){let e=t.get(n);if(r!==e||!Object.is(r,e))return!1}return!0}function i(e,t){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}exports.isShallowEqual=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;if(e instanceof Map&&t instanceof Map)return r(e,t);if(e instanceof Set&&t instanceof Set)return i(e,t);let n=Object.keys(e);if(n.length!==Object.keys(t).length)return!1;for(let r of n){if(!Object.hasOwn(t,r))return!1;let{[r]:n}=e,{[r]:i}=t;if(n!==i||!Object.is(n,i))return!1}return!0}function r(e,t){if(e.size!==t.size)return!1;for(let[n,r]of e){let e=t.get(n);if(r!==e||!Object.is(r,e))return!1}return!0}function i(e,t){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}exports.isShallowEqual=t;
 //# sourceMappingURL=is-shallow-equal.cjs.map

package/dist/is-shallow-equal.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-shallow-equal.cjs","names":["curry"],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they\n * are semantically different (e.g. resolved promises); but `isDeepEqual` does\n * compare the latter 2 semantically by-value.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(data, other)\n * @example\n *    isShallowEqual(1, 1) //=> true\n *    isShallowEqual(1, '1') //=> false\n *    isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true\n *    isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isShallowEqual<T>(data: T, other: T): boolean;\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,\n * even when they are semantically different (e.g. resolved promises). Use\n * `isDeepEqual` instead.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(other)(data)\n * @example\n *    pipe(1, isShallowEqual(1)) //=> true\n *    pipe(1, isShallowEqual('1')) //=> false\n *    pipe([1, 2, 3], isShallowEqual([1, 2, 3])) //=> true\n *    pipe([[1], [2], [3]], isShallowEqual([[1], [2], [3]])) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isShallowEqual<T>(other: T): (data: T) => boolean;\n\nexport function isShallowEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isShallowEqualImplementation, args);\n}\n\nfunction isShallowEqualImplementation<T>(a: T, b: T): boolean {\n  if (a === b || Object.is(a, b)) {\n    return true;\n  }\n\n  if (\n    typeof a !== 'object'\n    || a === null\n    || typeof b !== 'object'\n    || b === null\n  ) {\n    return false;\n  }\n\n  if (a instanceof Map && b instanceof Map) {\n    return isMapShallowEqual(a, b);\n  }\n\n  if (a instanceof Set && b instanceof Set) {\n    return isSetShallowEqual(a, b);\n  }\n\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) {\n    return false;\n  }\n\n  for (const key of keys) {\n    if (!Object.hasOwn(b, key)) {\n      return false;\n    }\n\n    const { [key as keyof T]: valueA } = a;\n    const { [key as keyof T]: valueB } = b;\n\n    if (valueA !== valueB || !Object.is(valueA, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isMapShallowEqual(\n  a: ReadonlyMap<unknown, unknown>,\n  b: ReadonlyMap<unknown, unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a) {\n    const valueB = b.get(key);\n    if (value !== valueB || !Object.is(value, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isSetShallowEqual(\n  a: ReadonlySet<unknown>,\n  b: ReadonlySet<unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const value of a) {\n    if (!b.has(value)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"kGAoFA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAOA,EAAAA,MAAM,EAA8B,EAAK,CAGlD,SAAS,EAAgC,EAAM,EAAe,CAC5D,GAAI,IAAM,GAAK,OAAO,GAAG,EAAG,EAAE,CAC5B,MAAO,GAGT,GACE,OAAO,GAAM,WACV,GACA,OAAO,GAAM,WACb,EAEH,MAAO,GAGT,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,IAAM,EAAO,OAAO,KAAK,EAAE,CAC3B,GAAI,EAAK,SAAW,OAAO,KAAK,EAAE,CAAC,OACjC,MAAO,GAGT,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,CAAC,OAAO,OAAO,EAAG,EAAI,CACxB,MAAO,GAGT,GAAM,EAAG,GAAiB,GAAW,EAC/B,EAAG,GAAiB,GAAW,EAErC,GAAI,IAAW,GAAU,CAAC,OAAO,GAAG,EAAQ,EAAO,CACjD,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,EAAG,CAC5B,IAAM,EAAS,EAAE,IAAI,EAAI,CACzB,GAAI,IAAU,GAAU,CAAC,OAAO,GAAG,EAAO,EAAO,CAC/C,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,IAAM,KAAS,EAClB,GAAI,CAAC,EAAE,IAAI,EAAM,CACf,MAAO,GAIX,MAAO"}
+{"version":3,"file":"is-shallow-equal.cjs","names":["curry"],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they\n * are semantically different (e.g. resolved promises); but `isDeepEqual` does\n * compare the latter 2 semantically by-value.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(data, other)\n * @example\n *    isShallowEqual(1, 1) //=> true\n *    isShallowEqual(1, '1') //=> false\n *    isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true\n *    isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isShallowEqual<T>(data: T, other: T): boolean;\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,\n * even when they are semantically different (e.g. resolved promises). Use\n * `isDeepEqual` instead.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(other)(data)\n * @example\n *    pipe(1, isShallowEqual(1)) //=> true\n *    pipe(1, isShallowEqual('1')) //=> false\n *    pipe([1, 2, 3], isShallowEqual([1, 2, 3])) //=> true\n *    pipe([[1], [2], [3]], isShallowEqual([[1], [2], [3]])) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isShallowEqual<T>(other: T): (data: T) => boolean;\n\nexport function isShallowEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isShallowEqualImplementation, args);\n}\n\nfunction isShallowEqualImplementation<T>(a: T, b: T): boolean {\n  if (a === b || Object.is(a, b)) {\n    return true;\n  }\n\n  if (\n    typeof a !== 'object'\n    || a === null\n    || typeof b !== 'object'\n    || b === null\n  ) {\n    return false;\n  }\n\n  if (a instanceof Map && b instanceof Map) {\n    return isMapShallowEqual(a, b);\n  }\n\n  if (a instanceof Set && b instanceof Set) {\n    return isSetShallowEqual(a, b);\n  }\n\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) {\n    return false;\n  }\n\n  for (const key of keys) {\n    if (!Object.hasOwn(b, key)) {\n      return false;\n    }\n\n    const { [key as keyof T]: valueA } = a;\n    const { [key as keyof T]: valueB } = b;\n\n    if (valueA !== valueB || !Object.is(valueA, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isMapShallowEqual(\n  a: ReadonlyMap<unknown, unknown>,\n  b: ReadonlyMap<unknown, unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a) {\n    const valueB = b.get(key);\n    if (value !== valueB || !Object.is(value, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isSetShallowEqual(\n  a: ReadonlySet<unknown>,\n  b: ReadonlySet<unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const value of a) {\n    if (!b.has(value)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"kGAoFA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAOA,EAAAA,MAAM,EAA8B,CAAI,CACjD,CAEA,SAAS,EAAgC,EAAM,EAAe,CAC5D,GAAI,IAAM,GAAK,OAAO,GAAG,EAAG,CAAC,EAC3B,MAAO,GAGT,GACE,OAAO,GAAM,WACV,GACA,OAAO,GAAM,WACb,EAEH,MAAO,GAGT,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,CAAC,EAG/B,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,CAAC,EAG/B,IAAM,EAAO,OAAO,KAAK,CAAC,EAC1B,GAAI,EAAK,SAAW,OAAO,KAAK,CAAC,CAAC,CAAC,OACjC,MAAO,GAGT,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,CAAC,OAAO,OAAO,EAAG,CAAG,EACvB,MAAO,GAGT,GAAM,EAAG,GAAiB,GAAW,EAC/B,EAAG,GAAiB,GAAW,EAErC,GAAI,IAAW,GAAU,CAAC,OAAO,GAAG,EAAQ,CAAM,EAChD,MAAO,EAEX,CAEA,MAAO,EACT,CAEA,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,EAAG,CAC5B,IAAM,EAAS,EAAE,IAAI,CAAG,EACxB,GAAI,IAAU,GAAU,CAAC,OAAO,GAAG,EAAO,CAAM,EAC9C,MAAO,EAEX,CAEA,MAAO,EACT,CAEA,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,IAAM,KAAS,EAClB,GAAI,CAAC,EAAE,IAAI,CAAK,EACd,MAAO,GAIX,MAAO,EACT"}

package/dist/is-shallow-equal.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-shallow-equal.js","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they\n * are semantically different (e.g. resolved promises); but `isDeepEqual` does\n * compare the latter 2 semantically by-value.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(data, other)\n * @example\n *    isShallowEqual(1, 1) //=> true\n *    isShallowEqual(1, '1') //=> false\n *    isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true\n *    isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isShallowEqual<T>(data: T, other: T): boolean;\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,\n * even when they are semantically different (e.g. resolved promises). Use\n * `isDeepEqual` instead.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(other)(data)\n * @example\n *    pipe(1, isShallowEqual(1)) //=> true\n *    pipe(1, isShallowEqual('1')) //=> false\n *    pipe([1, 2, 3], isShallowEqual([1, 2, 3])) //=> true\n *    pipe([[1], [2], [3]], isShallowEqual([[1], [2], [3]])) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isShallowEqual<T>(other: T): (data: T) => boolean;\n\nexport function isShallowEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isShallowEqualImplementation, args);\n}\n\nfunction isShallowEqualImplementation<T>(a: T, b: T): boolean {\n  if (a === b || Object.is(a, b)) {\n    return true;\n  }\n\n  if (\n    typeof a !== 'object'\n    || a === null\n    || typeof b !== 'object'\n    || b === null\n  ) {\n    return false;\n  }\n\n  if (a instanceof Map && b instanceof Map) {\n    return isMapShallowEqual(a, b);\n  }\n\n  if (a instanceof Set && b instanceof Set) {\n    return isSetShallowEqual(a, b);\n  }\n\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) {\n    return false;\n  }\n\n  for (const key of keys) {\n    if (!Object.hasOwn(b, key)) {\n      return false;\n    }\n\n    const { [key as keyof T]: valueA } = a;\n    const { [key as keyof T]: valueB } = b;\n\n    if (valueA !== valueB || !Object.is(valueA, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isMapShallowEqual(\n  a: ReadonlyMap<unknown, unknown>,\n  b: ReadonlyMap<unknown, unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a) {\n    const valueB = b.get(key);\n    if (value !== valueB || !Object.is(value, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isSetShallowEqual(\n  a: ReadonlySet<unknown>,\n  b: ReadonlySet<unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const value of a) {\n    if (!b.has(value)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"mCAoFA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAO,EAAM,EAA8B,EAAK,CAGlD,SAAS,EAAgC,EAAM,EAAe,CAC5D,GAAI,IAAM,GAAK,OAAO,GAAG,EAAG,EAAE,CAC5B,MAAO,GAGT,GACE,OAAO,GAAM,WACV,GACA,OAAO,GAAM,WACb,EAEH,MAAO,GAGT,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,IAAM,EAAO,OAAO,KAAK,EAAE,CAC3B,GAAI,EAAK,SAAW,OAAO,KAAK,EAAE,CAAC,OACjC,MAAO,GAGT,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,CAAC,OAAO,OAAO,EAAG,EAAI,CACxB,MAAO,GAGT,GAAM,EAAG,GAAiB,GAAW,EAC/B,EAAG,GAAiB,GAAW,EAErC,GAAI,IAAW,GAAU,CAAC,OAAO,GAAG,EAAQ,EAAO,CACjD,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,EAAG,CAC5B,IAAM,EAAS,EAAE,IAAI,EAAI,CACzB,GAAI,IAAU,GAAU,CAAC,OAAO,GAAG,EAAO,EAAO,CAC/C,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,IAAM,KAAS,EAClB,GAAI,CAAC,EAAE,IAAI,EAAM,CACf,MAAO,GAIX,MAAO"}
+{"version":3,"file":"is-shallow-equal.js","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they\n * are semantically different (e.g. resolved promises); but `isDeepEqual` does\n * compare the latter 2 semantically by-value.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(data, other)\n * @example\n *    isShallowEqual(1, 1) //=> true\n *    isShallowEqual(1, '1') //=> false\n *    isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true\n *    isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isShallowEqual<T>(data: T, other: T): boolean;\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,\n * even when they are semantically different (e.g. resolved promises). Use\n * `isDeepEqual` instead.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(other)(data)\n * @example\n *    pipe(1, isShallowEqual(1)) //=> true\n *    pipe(1, isShallowEqual('1')) //=> false\n *    pipe([1, 2, 3], isShallowEqual([1, 2, 3])) //=> true\n *    pipe([[1], [2], [3]], isShallowEqual([[1], [2], [3]])) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isShallowEqual<T>(other: T): (data: T) => boolean;\n\nexport function isShallowEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isShallowEqualImplementation, args);\n}\n\nfunction isShallowEqualImplementation<T>(a: T, b: T): boolean {\n  if (a === b || Object.is(a, b)) {\n    return true;\n  }\n\n  if (\n    typeof a !== 'object'\n    || a === null\n    || typeof b !== 'object'\n    || b === null\n  ) {\n    return false;\n  }\n\n  if (a instanceof Map && b instanceof Map) {\n    return isMapShallowEqual(a, b);\n  }\n\n  if (a instanceof Set && b instanceof Set) {\n    return isSetShallowEqual(a, b);\n  }\n\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) {\n    return false;\n  }\n\n  for (const key of keys) {\n    if (!Object.hasOwn(b, key)) {\n      return false;\n    }\n\n    const { [key as keyof T]: valueA } = a;\n    const { [key as keyof T]: valueB } = b;\n\n    if (valueA !== valueB || !Object.is(valueA, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isMapShallowEqual(\n  a: ReadonlyMap<unknown, unknown>,\n  b: ReadonlyMap<unknown, unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a) {\n    const valueB = b.get(key);\n    if (value !== valueB || !Object.is(value, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isSetShallowEqual(\n  a: ReadonlySet<unknown>,\n  b: ReadonlySet<unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const value of a) {\n    if (!b.has(value)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"mCAoFA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAO,EAAM,EAA8B,CAAI,CACjD,CAEA,SAAS,EAAgC,EAAM,EAAe,CAC5D,GAAI,IAAM,GAAK,OAAO,GAAG,EAAG,CAAC,EAC3B,MAAO,GAGT,GACE,OAAO,GAAM,WACV,GACA,OAAO,GAAM,WACb,EAEH,MAAO,GAGT,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,CAAC,EAG/B,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,CAAC,EAG/B,IAAM,EAAO,OAAO,KAAK,CAAC,EAC1B,GAAI,EAAK,SAAW,OAAO,KAAK,CAAC,CAAC,CAAC,OACjC,MAAO,GAGT,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,CAAC,OAAO,OAAO,EAAG,CAAG,EACvB,MAAO,GAGT,GAAM,EAAG,GAAiB,GAAW,EAC/B,EAAG,GAAiB,GAAW,EAErC,GAAI,IAAW,GAAU,CAAC,OAAO,GAAG,EAAQ,CAAM,EAChD,MAAO,EAEX,CAEA,MAAO,EACT,CAEA,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,EAAG,CAC5B,IAAM,EAAS,EAAE,IAAI,CAAG,EACxB,GAAI,IAAU,GAAU,CAAC,OAAO,GAAG,EAAO,CAAM,EAC9C,MAAO,EAEX,CAEA,MAAO,EACT,CAEA,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,IAAM,KAAS,EAClB,GAAI,CAAC,EAAE,IAAI,CAAK,EACd,MAAO,GAIX,MAAO,EACT"}

package/dist/is-strict-equal.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e===t||Object.is(e,t)}exports.isStrictEqual=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){return e===t||Object.is(e,t)}exports.isStrictEqual=t;
 //# sourceMappingURL=is-strict-equal.cjs.map

package/dist/is-strict-equal.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-strict-equal.cjs","names":["curry"],"sources":["../src/is-strict-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(data, other)\n * @example\n *    isStrictEqual(1, 1) //=> true\n *    isStrictEqual(1, '1') //=> false\n *    isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isStrictEqual<T>(data: T, other: T): boolean;\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(other)(data)\n * @example\n *    pipe(1, isStrictEqual(1)); //=> true\n *    pipe(1, isStrictEqual('1')); //=> false\n *    pipe([1, 2, 3], isStrictEqual([1, 2, 3])); //=> false\n * @dataLast\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isStrictEqual<T>(other: T): (data: T) => boolean;\n\nexport function isStrictEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isStrictlyEqualImplementation, args);\n}\n\nfunction isStrictlyEqualImplementation<T>(data: unknown, other: T): data is T {\n  return data === other || Object.is(data, other);\n}\n"],"mappings":"kGAwEA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAOA,EAAAA,MAAM,EAA+B,EAAK,CAGnD,SAAS,EAAiC,EAAe,EAAqB,CAC5E,OAAO,IAAS,GAAS,OAAO,GAAG,EAAM,EAAM"}
+{"version":3,"file":"is-strict-equal.cjs","names":["curry"],"sources":["../src/is-strict-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(data, other)\n * @example\n *    isStrictEqual(1, 1) //=> true\n *    isStrictEqual(1, '1') //=> false\n *    isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isStrictEqual<T>(data: T, other: T): boolean;\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(other)(data)\n * @example\n *    pipe(1, isStrictEqual(1)); //=> true\n *    pipe(1, isStrictEqual('1')); //=> false\n *    pipe([1, 2, 3], isStrictEqual([1, 2, 3])); //=> false\n * @dataLast\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isStrictEqual<T>(other: T): (data: T) => boolean;\n\nexport function isStrictEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isStrictlyEqualImplementation, args);\n}\n\nfunction isStrictlyEqualImplementation<T>(data: unknown, other: T): data is T {\n  return data === other || Object.is(data, other);\n}\n"],"mappings":"kGAwEA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAOA,EAAAA,MAAM,EAA+B,CAAI,CAClD,CAEA,SAAS,EAAiC,EAAe,EAAqB,CAC5E,OAAO,IAAS,GAAS,OAAO,GAAG,EAAM,CAAK,CAChD"}

package/dist/is-strict-equal.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-strict-equal.js","names":[],"sources":["../src/is-strict-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(data, other)\n * @example\n *    isStrictEqual(1, 1) //=> true\n *    isStrictEqual(1, '1') //=> false\n *    isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isStrictEqual<T>(data: T, other: T): boolean;\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(other)(data)\n * @example\n *    pipe(1, isStrictEqual(1)); //=> true\n *    pipe(1, isStrictEqual('1')); //=> false\n *    pipe([1, 2, 3], isStrictEqual([1, 2, 3])); //=> false\n * @dataLast\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isStrictEqual<T>(other: T): (data: T) => boolean;\n\nexport function isStrictEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isStrictlyEqualImplementation, args);\n}\n\nfunction isStrictlyEqualImplementation<T>(data: unknown, other: T): data is T {\n  return data === other || Object.is(data, other);\n}\n"],"mappings":"mCAwEA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA+B,EAAK,CAGnD,SAAS,EAAiC,EAAe,EAAqB,CAC5E,OAAO,IAAS,GAAS,OAAO,GAAG,EAAM,EAAM"}
+{"version":3,"file":"is-strict-equal.js","names":[],"sources":["../src/is-strict-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(data, other)\n * @example\n *    isStrictEqual(1, 1) //=> true\n *    isStrictEqual(1, '1') //=> false\n *    isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isStrictEqual<T>(data: T, other: T): boolean;\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(other)(data)\n * @example\n *    pipe(1, isStrictEqual(1)); //=> true\n *    pipe(1, isStrictEqual('1')); //=> false\n *    pipe([1, 2, 3], isStrictEqual([1, 2, 3])); //=> false\n * @dataLast\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isStrictEqual<T>(other: T): (data: T) => boolean;\n\nexport function isStrictEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isStrictlyEqualImplementation, args);\n}\n\nfunction isStrictlyEqualImplementation<T>(data: unknown, other: T): data is T {\n  return data === other || Object.is(data, other);\n}\n"],"mappings":"mCAwEA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA+B,CAAI,CAClD,CAEA,SAAS,EAAiC,EAAe,EAAqB,CAC5E,OAAO,IAAS,GAAS,OAAO,GAAG,EAAM,CAAK,CAChD"}

package/dist/is-string.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-string.cjs","names":[],"sources":["../src/is-string.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a string and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a string, false otherwise.\n * @signature\n *    isString(data)\n * @example\n *    isString('string') //=> true\n *    isString(1) //=> false\n * @category Guard\n */\nexport function isString<T>(data: T | string): data is NarrowedTo<T, string> {\n  return typeof data === 'string';\n}\n"],"mappings":"mEAcA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS"}
+{"version":3,"file":"is-string.cjs","names":[],"sources":["../src/is-string.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a string and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a string, false otherwise.\n * @signature\n *    isString(data)\n * @example\n *    isString('string') //=> true\n *    isString(1) //=> false\n * @category Guard\n */\nexport function isString<T>(data: T | string): data is NarrowedTo<T, string> {\n  return typeof data === 'string';\n}\n"],"mappings":"mEAcA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,QACzB"}

package/dist/is-string.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-string.js","names":[],"sources":["../src/is-string.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a string and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a string, false otherwise.\n * @signature\n *    isString(data)\n * @example\n *    isString('string') //=> true\n *    isString(1) //=> false\n * @category Guard\n */\nexport function isString<T>(data: T | string): data is NarrowedTo<T, string> {\n  return typeof data === 'string';\n}\n"],"mappings":"AAcA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS"}
+{"version":3,"file":"is-string.js","names":[],"sources":["../src/is-string.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a string and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a string, false otherwise.\n * @signature\n *    isString(data)\n * @example\n *    isString('string') //=> true\n *    isString(1) //=> false\n * @category Guard\n */\nexport function isString<T>(data: T | string): data is NarrowedTo<T, string> {\n  return typeof data === 'string';\n}\n"],"mappings":"AAcA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,QACzB"}

package/dist/is-symbol.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-symbol.cjs","names":[],"sources":["../src/is-symbol.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a symbol and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a symbol, false otherwise.\n * @signature\n *    isSymbol(data)\n * @example\n *    isSymbol(Symbol('foo')) //=> true\n *    isSymbol(1) //=> false\n * @category Guard\n */\nexport function isSymbol<T>(data: T | symbol): data is NarrowedTo<T, symbol> {\n  return typeof data === 'symbol';\n}\n"],"mappings":"mEAcA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS"}
+{"version":3,"file":"is-symbol.cjs","names":[],"sources":["../src/is-symbol.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a symbol and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a symbol, false otherwise.\n * @signature\n *    isSymbol(data)\n * @example\n *    isSymbol(Symbol('foo')) //=> true\n *    isSymbol(1) //=> false\n * @category Guard\n */\nexport function isSymbol<T>(data: T | symbol): data is NarrowedTo<T, symbol> {\n  return typeof data === 'symbol';\n}\n"],"mappings":"mEAcA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,QACzB"}

package/dist/is-symbol.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-symbol.js","names":[],"sources":["../src/is-symbol.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a symbol and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a symbol, false otherwise.\n * @signature\n *    isSymbol(data)\n * @example\n *    isSymbol(Symbol('foo')) //=> true\n *    isSymbol(1) //=> false\n * @category Guard\n */\nexport function isSymbol<T>(data: T | symbol): data is NarrowedTo<T, symbol> {\n  return typeof data === 'symbol';\n}\n"],"mappings":"AAcA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS"}
+{"version":3,"file":"is-symbol.js","names":[],"sources":["../src/is-symbol.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a symbol and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a symbol, false otherwise.\n * @signature\n *    isSymbol(data)\n * @example\n *    isSymbol(Symbol('foo')) //=> true\n *    isSymbol(1) //=> false\n * @category Guard\n */\nexport function isSymbol<T>(data: T | symbol): data is NarrowedTo<T, symbol> {\n  return typeof data === 'symbol';\n}\n"],"mappings":"AAcA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,QACzB"}

package/dist/is-truthy.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-truthy.cjs","names":[],"sources":["../src/is-truthy.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is truthy and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is truthy, false otherwise.\n * @signature\n *    isTruthy(data)\n * @example\n *    isTruthy('somethingElse') //=> true\n *    isTruthy(null) //=> false\n *    isTruthy(undefined) //=> false\n *    isTruthy(false) //=> false\n *    isTruthy(0) //=> false\n *    isTruthy('') //=> false\n * @category Guard\n */\n\nexport function isTruthy<T>(\n  data: T,\n): data is Exclude<T, '' | 0 | false | null | undefined> {\n  return Boolean(data);\n}\n"],"mappings":"mEAiBA,SAAgB,EACd,EACuD,CACvD,MAAO,EAAQ"}
+{"version":3,"file":"is-truthy.cjs","names":[],"sources":["../src/is-truthy.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is truthy and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is truthy, false otherwise.\n * @signature\n *    isTruthy(data)\n * @example\n *    isTruthy('somethingElse') //=> true\n *    isTruthy(null) //=> false\n *    isTruthy(undefined) //=> false\n *    isTruthy(false) //=> false\n *    isTruthy(0) //=> false\n *    isTruthy('') //=> false\n * @category Guard\n */\n\nexport function isTruthy<T>(\n  data: T,\n): data is Exclude<T, '' | 0 | false | null | undefined> {\n  return Boolean(data);\n}\n"],"mappings":"mEAiBA,SAAgB,EACd,EACuD,CACvD,MAAO,EAAQ,CACjB"}

package/dist/is-truthy.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-truthy.js","names":[],"sources":["../src/is-truthy.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is truthy and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is truthy, false otherwise.\n * @signature\n *    isTruthy(data)\n * @example\n *    isTruthy('somethingElse') //=> true\n *    isTruthy(null) //=> false\n *    isTruthy(undefined) //=> false\n *    isTruthy(false) //=> false\n *    isTruthy(0) //=> false\n *    isTruthy('') //=> false\n * @category Guard\n */\n\nexport function isTruthy<T>(\n  data: T,\n): data is Exclude<T, '' | 0 | false | null | undefined> {\n  return Boolean(data);\n}\n"],"mappings":"AAiBA,SAAgB,EACd,EACuD,CACvD,MAAO,EAAQ"}
+{"version":3,"file":"is-truthy.js","names":[],"sources":["../src/is-truthy.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is truthy and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is truthy, false otherwise.\n * @signature\n *    isTruthy(data)\n * @example\n *    isTruthy('somethingElse') //=> true\n *    isTruthy(null) //=> false\n *    isTruthy(undefined) //=> false\n *    isTruthy(false) //=> false\n *    isTruthy(0) //=> false\n *    isTruthy('') //=> false\n * @category Guard\n */\n\nexport function isTruthy<T>(\n  data: T,\n): data is Exclude<T, '' | 0 | false | null | undefined> {\n  return Boolean(data);\n}\n"],"mappings":"AAiBA,SAAgB,EACd,EACuD,CACvD,MAAO,EAAQ,CACjB"}

package/dist/join.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e.join(t)}exports.join=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){return e.join(t)}exports.join=t;
 //# sourceMappingURL=join.cjs.map

package/dist/join.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"join.cjs","names":["curry"],"sources":["../src/join.ts"],"sourcesContent":["import type { Join } from 'type-fest';\nimport { curry } from './curry';\n\n// Copied from type-fest, from the Join type.\ntype JoinableItem = bigint | boolean | number | string | null | undefined;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param data - The array to join.\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(data, glue)\n * @example\n *    join([1,2,3], \",\") // => \"1,2,3\" (typed `string`)\n *    join(['a','b','c'], \"\") // => \"abc\" (typed `string`)\n *    join(['hello', 'world'] as const, \" \") // => \"hello world\" (typed `hello world`)\n * @dataFirst\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(data: T, glue: Glue): Join<T, Glue>;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(glue)(data)\n * @example\n *    pipe([1,2,3], join(\",\")) // => \"1,2,3\" (typed `string`)\n *    pipe(['a','b','c'], join(\"\")) // => \"abc\" (typed `string`)\n *    pipe(['hello', 'world'] as const, join(\" \")) // => \"hello world\" (typed `hello world`)\n * @dataLast\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(glue: Glue): (data: T) => Join<T, Glue>;\n\nexport function join(...args: ReadonlyArray<unknown>): unknown {\n  return curry(joinImplementation, args);\n}\n\nfunction joinImplementation(data: ReadonlyArray<unknown>, glue: string): string {\n  return data.join(glue);\n}\n"],"mappings":"kGAqDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAK,CAGxC,SAAS,EAAmB,EAA8B,EAAsB,CAC9E,OAAO,EAAK,KAAK,EAAK"}
+{"version":3,"file":"join.cjs","names":["curry"],"sources":["../src/join.ts"],"sourcesContent":["import type { Join } from 'type-fest';\nimport { curry } from './curry';\n\n// Copied from type-fest, from the Join type.\ntype JoinableItem = bigint | boolean | number | string | null | undefined;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param data - The array to join.\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(data, glue)\n * @example\n *    join([1,2,3], \",\") // => \"1,2,3\" (typed `string`)\n *    join(['a','b','c'], \"\") // => \"abc\" (typed `string`)\n *    join(['hello', 'world'] as const, \" \") // => \"hello world\" (typed `hello world`)\n * @dataFirst\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(data: T, glue: Glue): Join<T, Glue>;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(glue)(data)\n * @example\n *    pipe([1,2,3], join(\",\")) // => \"1,2,3\" (typed `string`)\n *    pipe(['a','b','c'], join(\"\")) // => \"abc\" (typed `string`)\n *    pipe(['hello', 'world'] as const, join(\" \")) // => \"hello world\" (typed `hello world`)\n * @dataLast\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(glue: Glue): (data: T) => Join<T, Glue>;\n\nexport function join(...args: ReadonlyArray<unknown>): unknown {\n  return curry(joinImplementation, args);\n}\n\nfunction joinImplementation(data: ReadonlyArray<unknown>, glue: string): string {\n  return data.join(glue);\n}\n"],"mappings":"kGAqDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,CAAI,CACvC,CAEA,SAAS,EAAmB,EAA8B,EAAsB,CAC9E,OAAO,EAAK,KAAK,CAAI,CACvB"}

package/dist/join.js.map

@@ -1 +1 @@
-{"version":3,"file":"join.js","names":[],"sources":["../src/join.ts"],"sourcesContent":["import type { Join } from 'type-fest';\nimport { curry } from './curry';\n\n// Copied from type-fest, from the Join type.\ntype JoinableItem = bigint | boolean | number | string | null | undefined;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param data - The array to join.\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(data, glue)\n * @example\n *    join([1,2,3], \",\") // => \"1,2,3\" (typed `string`)\n *    join(['a','b','c'], \"\") // => \"abc\" (typed `string`)\n *    join(['hello', 'world'] as const, \" \") // => \"hello world\" (typed `hello world`)\n * @dataFirst\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(data: T, glue: Glue): Join<T, Glue>;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(glue)(data)\n * @example\n *    pipe([1,2,3], join(\",\")) // => \"1,2,3\" (typed `string`)\n *    pipe(['a','b','c'], join(\"\")) // => \"abc\" (typed `string`)\n *    pipe(['hello', 'world'] as const, join(\" \")) // => \"hello world\" (typed `hello world`)\n * @dataLast\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(glue: Glue): (data: T) => Join<T, Glue>;\n\nexport function join(...args: ReadonlyArray<unknown>): unknown {\n  return curry(joinImplementation, args);\n}\n\nfunction joinImplementation(data: ReadonlyArray<unknown>, glue: string): string {\n  return data.join(glue);\n}\n"],"mappings":"mCAqDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EAAmB,EAA8B,EAAsB,CAC9E,OAAO,EAAK,KAAK,EAAK"}
+{"version":3,"file":"join.js","names":[],"sources":["../src/join.ts"],"sourcesContent":["import type { Join } from 'type-fest';\nimport { curry } from './curry';\n\n// Copied from type-fest, from the Join type.\ntype JoinableItem = bigint | boolean | number | string | null | undefined;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param data - The array to join.\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(data, glue)\n * @example\n *    join([1,2,3], \",\") // => \"1,2,3\" (typed `string`)\n *    join(['a','b','c'], \"\") // => \"abc\" (typed `string`)\n *    join(['hello', 'world'] as const, \" \") // => \"hello world\" (typed `hello world`)\n * @dataFirst\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(data: T, glue: Glue): Join<T, Glue>;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(glue)(data)\n * @example\n *    pipe([1,2,3], join(\",\")) // => \"1,2,3\" (typed `string`)\n *    pipe(['a','b','c'], join(\"\")) // => \"abc\" (typed `string`)\n *    pipe(['hello', 'world'] as const, join(\" \")) // => \"hello world\" (typed `hello world`)\n * @dataLast\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(glue: Glue): (data: T) => Join<T, Glue>;\n\nexport function join(...args: ReadonlyArray<unknown>): unknown {\n  return curry(joinImplementation, args);\n}\n\nfunction joinImplementation(data: ReadonlyArray<unknown>, glue: string): string {\n  return data.join(glue);\n}\n"],"mappings":"mCAqDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,CAAI,CACvC,CAEA,SAAS,EAAmB,EAA8B,EAAsB,CAC9E,OAAO,EAAK,KAAK,CAAI,CACvB"}

package/dist/key-codes.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"key-codes.cjs","names":[],"sources":["../src/key-codes.ts"],"sourcesContent":["/**\n * Using event.code is not predictable since each machine may have different output\n */\n\nexport const KEY_CODES = {\n  ALT: 'Alt',\n  ARROW_DOWN: 'ArrowDown',\n  ARROW_LEFT: 'ArrowLeft',\n  ARROW_RIGHT: 'ArrowRight',\n  ARROW_UP: 'ArrowUp',\n  AT: '@',\n  BACKSPACE: 'Backspace',\n  CTRL: 'Control',\n  DELETE: 'Delete',\n  END: 'End',\n  ENTER: 'Enter',\n  ESC: 'Escape',\n  HOME: 'Home',\n  KEY_F: 'KEY_F',\n  META: 'Meta',\n  PAGE_DOWN: 'PageDown',\n  PAGE_UP: 'PageUp',\n  SHIFT: 'Shift',\n  SPACE: 'Space',\n  TAB: 'Tab',\n} as const;\n"],"mappings":"mEAIA,MAAa,EAAY,CACvB,IAAK,MACL,WAAY,YACZ,WAAY,YACZ,YAAa,aACb,SAAU,UACV,GAAI,IACJ,UAAW,YACX,KAAM,UACN,OAAQ,SACR,IAAK,MACL,MAAO,QACP,IAAK,SACL,KAAM,OACN,MAAO,QACP,KAAM,OACN,UAAW,WACX,QAAS,SACT,MAAO,QACP,MAAO,QACP,IAAK,MACN"}
+{"version":3,"file":"key-codes.cjs","names":[],"sources":["../src/key-codes.ts"],"sourcesContent":["/**\n * Using event.code is not predictable since each machine may have different output\n */\n\nexport const KEY_CODES = {\n  ALT: 'Alt',\n  ARROW_DOWN: 'ArrowDown',\n  ARROW_LEFT: 'ArrowLeft',\n  ARROW_RIGHT: 'ArrowRight',\n  ARROW_UP: 'ArrowUp',\n  AT: '@',\n  BACKSPACE: 'Backspace',\n  CTRL: 'Control',\n  DELETE: 'Delete',\n  END: 'End',\n  ENTER: 'Enter',\n  ESC: 'Escape',\n  HOME: 'Home',\n  KEY_F: 'KEY_F',\n  META: 'Meta',\n  PAGE_DOWN: 'PageDown',\n  PAGE_UP: 'PageUp',\n  SHIFT: 'Shift',\n  SPACE: 'Space',\n  TAB: 'Tab',\n} as const;\n"],"mappings":"mEAIA,MAAa,EAAY,CACvB,IAAK,MACL,WAAY,YACZ,WAAY,YACZ,YAAa,aACb,SAAU,UACV,GAAI,IACJ,UAAW,YACX,KAAM,UACN,OAAQ,SACR,IAAK,MACL,MAAO,QACP,IAAK,SACL,KAAM,OACN,MAAO,QACP,KAAM,OACN,UAAW,WACX,QAAS,SACT,MAAO,QACP,MAAO,QACP,IAAK,KACP"}

package/dist/key-codes.js.map

@@ -1 +1 @@
-{"version":3,"file":"key-codes.js","names":[],"sources":["../src/key-codes.ts"],"sourcesContent":["/**\n * Using event.code is not predictable since each machine may have different output\n */\n\nexport const KEY_CODES = {\n  ALT: 'Alt',\n  ARROW_DOWN: 'ArrowDown',\n  ARROW_LEFT: 'ArrowLeft',\n  ARROW_RIGHT: 'ArrowRight',\n  ARROW_UP: 'ArrowUp',\n  AT: '@',\n  BACKSPACE: 'Backspace',\n  CTRL: 'Control',\n  DELETE: 'Delete',\n  END: 'End',\n  ENTER: 'Enter',\n  ESC: 'Escape',\n  HOME: 'Home',\n  KEY_F: 'KEY_F',\n  META: 'Meta',\n  PAGE_DOWN: 'PageDown',\n  PAGE_UP: 'PageUp',\n  SHIFT: 'Shift',\n  SPACE: 'Space',\n  TAB: 'Tab',\n} as const;\n"],"mappings":"AAIA,MAAa,EAAY,CACvB,IAAK,MACL,WAAY,YACZ,WAAY,YACZ,YAAa,aACb,SAAU,UACV,GAAI,IACJ,UAAW,YACX,KAAM,UACN,OAAQ,SACR,IAAK,MACL,MAAO,QACP,IAAK,SACL,KAAM,OACN,MAAO,QACP,KAAM,OACN,UAAW,WACX,QAAS,SACT,MAAO,QACP,MAAO,QACP,IAAK,MACN"}
+{"version":3,"file":"key-codes.js","names":[],"sources":["../src/key-codes.ts"],"sourcesContent":["/**\n * Using event.code is not predictable since each machine may have different output\n */\n\nexport const KEY_CODES = {\n  ALT: 'Alt',\n  ARROW_DOWN: 'ArrowDown',\n  ARROW_LEFT: 'ArrowLeft',\n  ARROW_RIGHT: 'ArrowRight',\n  ARROW_UP: 'ArrowUp',\n  AT: '@',\n  BACKSPACE: 'Backspace',\n  CTRL: 'Control',\n  DELETE: 'Delete',\n  END: 'End',\n  ENTER: 'Enter',\n  ESC: 'Escape',\n  HOME: 'Home',\n  KEY_F: 'KEY_F',\n  META: 'Meta',\n  PAGE_DOWN: 'PageDown',\n  PAGE_UP: 'PageUp',\n  SHIFT: 'Shift',\n  SPACE: 'Space',\n  TAB: 'Tab',\n} as const;\n"],"mappings":"AAIA,MAAa,EAAY,CACvB,IAAK,MACL,WAAY,YACZ,WAAY,YACZ,YAAa,aACb,SAAU,UACV,GAAI,IACJ,UAAW,YACX,KAAM,UACN,OAAQ,SACR,IAAK,MACL,MAAO,QACP,IAAK,SACL,KAAM,OACN,MAAO,QACP,KAAM,OACN,UAAW,WACX,QAAS,SACT,MAAO,QACP,MAAO,QACP,IAAK,KACP"}

package/dist/keys.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(Object.keys,t)}exports.keys=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(Object.keys,t)}exports.keys=t;
 //# sourceMappingURL=keys.cjs.map