type-plus 7.6.2 → 8.0.0-beta.2

package/esm/bigint/strict_bigint_type.d.ts

@@ -1,56 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js';
-/**
- * Check if the type `T` is exactly `bigint`.
- *
- * ```ts
- * type R = StrictBigintType<bigint> // bigint
- *
- * type R = StrictBigintType<1n> // never
- * type R = StrictBigintType<number> // never
- * type R = StrictBigintType<bigint | boolean> // never
- * type R = StrictBigintType<unknown> // never
- * ```
- */
-export type StrictBigintType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [
-    bigint
-] extends [T] ? ([T] extends [bigint] ? (`${T}` extends `${number}` ? Else : Then) : Else) : Else>;
-/**
- * Is the type `T` exactly `bigint`.
- *
- * ```ts
- * type R = IsStrictBigint<bigint> // true
- *
- * type R = IsStrictBigint<1n> // false
- * type R = IsStrictBigint<number> // false
- * type R = IsStrictBigint<bigint | boolean> // false
- * type R = IsStrictBigint<unknown> // false
- * ```
- */
-export type IsStrictBigint<T, Then = true, Else = false> = StrictBigintType<T, Then, Else>;
-/**
- * Check if the type `T` is not exactly `bigint`.
- *
- * ```ts
- * type R = NotStrictBigintType<bigint> // never
- *
- * type R = NotStrictBigintType<1n> // 1n
- * type R = NotStrictBigintType<number> // number
- * type R = NotStrictBigintType<bigint | boolean> // string | boolean
- * type R = NotStrictBigintType<unknown> // unknown
- * ```
- */
-export type NotStrictBigintType<T, Then = T, Else = never> = StrictBigintType<T, Else, Then>;
-/**
- * Is the type `T` not exactly `bigint`.
- *
- * ```ts
- * type R = IsNotStrictBigint<bigint> // false
- *
- * type R = IsNotStrictBigint<1n> // true
- * type R = IsNotStrictBigint<number> // true
- * type R = IsNotStrictBigint<bigint | boolean> // true
- * type R = IsNotStrictBigint<unknown> // true
- * ```
- */
-export type IsNotStrictBigint<T, Then = true, Else = false> = StrictBigintType<T, Else, Then>;
-//# sourceMappingURL=strict_bigint_type.d.ts.map

package/esm/bigint/strict_bigint_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strict_bigint_type.d.ts","sourceRoot":"","sources":["../../ts/bigint/strict_bigint_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAA;AAErE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CACrE,CAAC,EACD,IAAI,EACJ;IAAC,MAAM;CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,SAAS,GAAG,MAAM,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CACxG,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE1F;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE5F;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/bigint/strict_bigint_type.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=strict_bigint_type.js.map

package/esm/bigint/strict_bigint_type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strict_bigint_type.js","sourceRoot":"","sources":["../../ts/bigint/strict_bigint_type.ts"],"names":[],"mappings":""}

package/esm/boolean/boolean_type.d.ts

@@ -1,56 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js';
-/**
- * Check if the type `T` is `boolean`, including `true` and `false`.
- *
- * ```ts
- * type R = BooleanType<boolean> // boolean
- * type R = BooleanType<true> // true
- * type R = BooleanType<false> // false
- *
- * type R = BooleanType<number> // never
- * type R = BooleanType<unknown> // never
- * ```
- */
-export type BooleanType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [
-    T
-] extends [boolean] ? Then : Else>;
-/**
- * Check if the type `T` is not `boolean`, including `true` and `false`.
- *
- * ```ts
- * type R = NotBooleanType<boolean> // never
- * type R = NotBooleanType<true> // never
- * type R = NotBooleanType<false> // never
- *
- * type R = NotBooleanType<number> // number
- * type R = NotBooleanType<unknown> // unknown
- * ```
- */
-export type NotBooleanType<T, Then = T, Else = never> = BooleanType<T, Else, Then>;
-/**
- * Is the type `T` `boolean`, including `true` and `false`.
- *
- * ```ts
- * type R = IsBoolean<boolean> // true
- * type R = IsBoolean<true> // true
- * type R = IsBoolean<false> // true
- *
- * type R = IsBoolean<number> // false
- * type R = IsBoolean<unknown> // false
- * ```
- */
-export type IsBoolean<T, Then = true, Else = false> = BooleanType<T, Then, Else>;
-/**
- * Is the type `T` not `boolean`, including `true` and `false`.
- *
- * ```ts
- * type R = IsNotBoolean<boolean> // false
- * type R = IsNotBoolean<true> // false
- * type R = IsNotBoolean<false> // false
- *
- * type R = IsNotBoolean<number> // true
- * type R = IsNotBoolean<unknown> // true
- * ```
- */
-export type IsNotBoolean<T, Then = true, Else = false> = BooleanType<T, Else, Then>;
-//# sourceMappingURL=boolean_type.d.ts.map

package/esm/boolean/boolean_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean_type.d.ts","sourceRoot":"","sources":["../../ts/boolean/boolean_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAA;AAErE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAChE,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,IAAI,CACnC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAElF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEhF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/boolean/boolean_type.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=boolean_type.js.map

package/esm/boolean/boolean_type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean_type.js","sourceRoot":"","sources":["../../ts/boolean/boolean_type.ts"],"names":[],"mappings":""}

package/esm/boolean/false_type.d.ts

@@ -1,49 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js';
-/**
- * Check if the type `T` is exactly `false`.
- *
- * ```ts
- * type R = FalseType<false> // false
- *
- * type R = FalseType<true> // never
- * type R = FalseType<unknown> // never
- * ```
- */
-export type FalseType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [
-    T,
-    false
-] extends [false, T] ? Then : Else>;
-/**
- * Check if the type `T` is not exactly `false`.
- *
- * ```ts
- * type R = NotFalseType<false> // never
- *
- * type R = NotFalseType<true> // true
- * type R = NotFalseType<unknown> // unknown
- * ```
- */
-export type NotFalseType<T, Then = T, Else = never> = FalseType<T, Else, Then>;
-/**
- * Is the type `T` exactly `false`.
- *
- * ```ts
- * type R = IsFalse<false> // true
- *
- * type R = IsFalse<true> // false
- * type R = IsFalse<unknown> // false
- * ```
- */
-export type IsFalse<T, Then = true, Else = false> = FalseType<T, Then, Else>;
-/**
- * Is the type `T` not exactly `false`.
- *
- * ```ts
- * type R = IsNotFalse<false> // false
- *
- * type R = IsNotFalse<true> // true
- * type R = IsNotFalse<unknown> // true
- * ```
- */
-export type IsNotFalse<T, Then = true, Else = false> = FalseType<T, Else, Then>;
-//# sourceMappingURL=false_type.d.ts.map

package/esm/boolean/false_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"false_type.d.ts","sourceRoot":"","sources":["../../ts/boolean/false_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAA;AAErE;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAC9D,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;IAAE,KAAK;CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAC3C,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE9E;;;;;;;;;GASG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE5E;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/boolean/false_type.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=false_type.js.map

package/esm/boolean/false_type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"false_type.js","sourceRoot":"","sources":["../../ts/boolean/false_type.ts"],"names":[],"mappings":""}

package/esm/boolean/strict_boolean_type.d.ts

@@ -1,53 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js';
-/**
- * Check if the type `T` is exactly `boolean`.
- *
- * ```ts
- * type R = StrictBooleanType<boolean> // true
- *
- * type R = StrictBooleanType<true> // never
- * type R = StrictBooleanType<false> // never
- * type R = StrictBooleanType<unknown> // never
- * ```
- */
-export type StrictBooleanType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [
-    T,
-    boolean
-] extends [boolean, T] ? Then : Else>;
-/**
- * Check if the type `T` is not exactly `boolean`.
- *
- * ```ts
- * type R = NotStrictBooleanType<boolean> // never
- *
- * type R = NotStrictBooleanType<true> // true
- * type R = NotStrictBooleanType<false> // false
- * type R = NotStrictBooleanType<unknown> // unknown
- * ```
- */
-export type NotStrictBooleanType<T, Then = T, Else = never> = StrictBooleanType<T, Else, Then>;
-/**
- * Is the type `T` exactly `boolean`.
- *
- * ```ts
- * type R = IsStrictBoolean<boolean> // true
- *
- * type R = IsStrictBoolean<true> // false
- * type R = IsStrictBoolean<false> // true
- * type R = IsStrictBoolean<unknown> // false
- * ```
- */
-export type IsStrictBoolean<T, Then = true, Else = false> = StrictBooleanType<T, Then, Else>;
-/**
- * Is the type `T` not exactly `false`.
- *
- * ```ts
- * type R = IsNotStrictBoolean<boolean> // false
- *
- * type R = IsNotStrictBoolean<true> // true
- * type R = IsNotStrictBoolean<false> // false
- * type R = IsNotStrictBoolean<unknown> // true
- * ```
- */
-export type IsNotStrictBoolean<T, Then = true, Else = false> = StrictBooleanType<T, Else, Then>;
-//# sourceMappingURL=strict_boolean_type.d.ts.map

package/esm/boolean/strict_boolean_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strict_boolean_type.d.ts","sourceRoot":"","sources":["../../ts/boolean/strict_boolean_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAA;AAErE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CACtE,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;IAAE,OAAO;CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAC/C,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE9F;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE5F;;;;;;;;;;GAUG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/boolean/strict_boolean_type.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=strict_boolean_type.js.map

package/esm/boolean/strict_boolean_type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strict_boolean_type.js","sourceRoot":"","sources":["../../ts/boolean/strict_boolean_type.ts"],"names":[],"mappings":""}

package/esm/boolean/true_type.d.ts

@@ -1,49 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js';
-/**
- * Check if the type `T` is exactly `true`.
- *
- * ```ts
- * type R = TrueType<true> // true
- *
- * type R = TrueType<false> // never
- * type R = TrueType<unknown> // never
- * ```
- */
-export type TrueType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [
-    T,
-    true
-] extends [true, T] ? Then : Else>;
-/**
- * Check if the type `T` is not exactly `true`.
- *
- * ```ts
- * type R = NotTrueType<true> // never
- *
- * type R = NotTrueType<false> // false
- * type R = NotTrueType<unknown> // unknown
- * ```
- */
-export type NotTrueType<T, Then = T, Else = never> = TrueType<T, Else, Then>;
-/**
- * Is the type `T` exactly `true`.
- *
- * ```ts
- * type R = IsTrue<true> // true
- *
- * type R = IsTrue<false> // false
- * type R = IsTrue<unknown> // false
- * ```
- */
-export type IsTrue<T, Then = true, Else = false> = TrueType<T, Then, Else>;
-/**
- * Is the type `T` not exactly `true`.
- *
- * ```ts
- * type R = IsNotTrue<true> // false
- *
- * type R = IsNotTrue<false> // true
- * type R = IsNotTrue<unknown> // true
- * ```
- */
-export type IsNotTrue<T, Then = true, Else = false> = TrueType<T, Else, Then>;
-//# sourceMappingURL=true_type.d.ts.map

package/esm/boolean/true_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"true_type.d.ts","sourceRoot":"","sources":["../../ts/boolean/true_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAA;AAErE;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAC7D,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;IAAE,IAAI;CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CACzC,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE5E;;;;;;;;;GASG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE1E;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/boolean/true_type.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=true_type.js.map

package/esm/boolean/true_type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"true_type.js","sourceRoot":"","sources":["../../ts/boolean/true_type.ts"],"names":[],"mappings":""}

package/esm/function/function_type.d.ts

@@ -1,59 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js';
-/**
- * Check if `T` is a `Function`.
- *
- * ```ts
- * type R = FunctionType<Function> // Function
- * type R = FunctionType<() => void> // () => void
- * type R = FunctionType<(() => void) | { a: 1 }> // (() => void) | { a: 1 }
- *
- * type R = FunctionType<{ a: 1 }> // never
- * type R = FunctionType<never> // never
- * type R = FunctionType<unknown> // never
- * ```
- */
-export type FunctionType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [
-    T
-] extends [Function] ? Then : Else>;
-/**
- * Is `T` a `Function`.
- *
- * ```ts
- * type R = IsFunction<Function> // Function
- * type R = IsFunction<() => void> // () => void
- * type R = IsFunction<(() => void) | { a: 1 }> // (() => void) | { a: 1 }
- *
- * type R = IsFunction<{ a: 1 }> // never
- * type R = IsFunction<never> // never
- * type R = IsFunction<unknown> // never
- * ```
- */
-export type IsFunction<T, Then = true, Else = false> = FunctionType<T, Then, Else>;
-/**
- * Check if `T` is not a `Function`.
- *
- * ```ts
- * type R = NotFunctionType<Function> // never
- * type R = NotFunctionType<() => void> // never
- * type R = NotFunctionType<(() => void) | { a: 1 }> // never
- *
- * type R = NotFunctionType<{ a: 1 }> // { a: 1 }
- * type R = NotFunctionType<never> // never
- * type R = NotFunctionType<unknown> // unknown
- * ```
- */
-export type NotFunctionType<T, Then = T, Else = never> = FunctionType<T, Else, Then>;
-/**
- * Is `T` not a `Function`.
- *
- * ```ts
- * type R = IsNotFunction<Function> // false
- * type R = IsNotFunction<() => void> // false
- * type R = IsNotFunction<(() => void) | { a: 1 }> // false
- *
- * type R = IsNotFunction<{ a: 1 }> // true
- * type R = IsNotFunction<never> // true
- * ```
- */
-export type IsNotFunction<T, Then = true, Else = false> = FunctionType<T, Else, Then>;
-//# sourceMappingURL=function_type.d.ts.map

package/esm/function/function_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function_type.d.ts","sourceRoot":"","sources":["../../ts/function/function_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAA;AAErE;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CACjE,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,IAAI,GAAG,IAAI,CACpC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAElF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEpF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/function/function_type.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=function_type.js.map

package/esm/function/function_type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"function_type.js","sourceRoot":"","sources":["../../ts/function/function_type.ts"],"names":[],"mappings":""}

package/esm/function/strict_function_type.d.ts

@@ -1,49 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js';
-/**
- * Check if `T` is exactly `Function`.
- *
- * ```ts
- * type R = StrictFunctionType<Function> // Function
- *
- * type R = StrictFunctionType<() => void> // never
- * type R = StrictFunctionType<Function & { a: 1 }> // never
- * ```
- */
-export type StrictFunctionType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [
-    T,
-    Function
-] extends [Function, T] ? Then : Else>;
-/**
- * Check if `T` is not exactly `Function`.
- *
- * ```ts
- * type R = NotStrictFunctionType<Function> // never
- * type R = NotStrictFunctionType<() => void> // () => void
- *
- * type R = NotStrictFunctionType<Function & { a: 1 }> // Function & { a: 1 }
- * ```
- */
-export type NotStrictFunctionType<T, Then = T, Else = never> = StrictFunctionType<T, Else, Then>;
-/**
- * Is `T` exactly `Function`.
- *
- * ```ts
- * type R = IsStrictFunction<Function> // true
- *
- * type R = IsStrictFunction<() => void> // false
- * type R = IsStrictFunction<(() => void) & { a: 1 }> // false
- * ```
- */
-export type IsStrictFunction<T, Then = true, Else = false> = StrictFunctionType<T, Then, Else>;
-/**
- * Is `T` not exactly `Function`.
- *
- * ```ts
- * type R = IsNotStrictFunction<Function> // false
- *
- * type R = IsNotStrictFunction<() => void> // true
- * type R = IsNotStrictFunction<(() => void) & { a: 1 }> // true
- * ```
- */
-export type IsNotStrictFunction<T, Then = true, Else = false> = StrictFunctionType<T, Else, Then>;
-//# sourceMappingURL=strict_function_type.d.ts.map

package/esm/function/strict_function_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strict_function_type.d.ts","sourceRoot":"","sources":["../../ts/function/strict_function_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAA;AAErE;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CACvE,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;IAAE,QAAQ;CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CACjD,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEhG;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE9F;;;;;;;;;GASG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/function/strict_function_type.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=strict_function_type.js.map

package/esm/function/strict_function_type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strict_function_type.js","sourceRoot":"","sources":["../../ts/function/strict_function_type.ts"],"names":[],"mappings":""}

package/esm/merge.d.ts

@@ -1,55 +0,0 @@
-import type { NonComposableTypes } from './composable_types.js';
-import type { AnyRecord } from './object/AnyRecord.js';
-import type { IsDisjoint } from './object/IsDisjoint.js';
-import type { KeyTypes } from './object/KeyTypes.js';
-import type { OptionalKeys } from './object/OptionalKeys.js';
-import type { Properties } from './object/properties.js';
-import type { IsLiteral } from './predicates/literal.js';
-/**
- * Left join type `A` with type `B`.
- *
- * It handles cases like A or B are `Record`,
- * joining between required and optional props, etc.
- */
-export type Merge<A, B> = [A, B] extends [NonComposableTypes, unknown] ? B : [A, B] extends [unknown, NonComposableTypes] ? A : A extends AnyRecord ? B extends AnyRecord ? IsDisjoint<A, B> extends true ? A & B : ([keyof A, keyof B] extends [infer KA extends KeyTypes, infer KB extends KeyTypes] ? (IsLiteral<KA> extends true ? (IsLiteral<KB> extends true ? ([OptionalKeys<A>, OptionalKeys<B>] extends [infer PKA extends KeyTypes, infer PKB extends KeyTypes] ? {
-    [k in PKA & PKB]?: A[k] | B[k] | undefined;
-} & {
-    [k in Exclude<KA & KB, PKA | PKB>]: Merge.JoinProps<A[k], B[k]>;
-} & {
-    [k in Exclude<KA, PKA | KB>]: A[k];
-} & {
-    [k in Exclude<KB, PKB>]: B[k];
-} & {
-    [k in Exclude<KA & PKB, PKA>]: Exclude<A[k] | Partial<B[k]>, undefined>;
-} : never) : Properties<{
-    [k in Exclude<KA, KA & KB>]: A[k];
-} & {
-    [k in Exclude<KB, KA & KB>]: B[k];
-} & {
-    [k in KA & KB]: A[k] | B[k];
-}>) : (IsLiteral<KB> extends true ? {
-    [k in Exclude<KA, KB>]: A[k];
-} & {
-    [k in keyof B]: B[k];
-} : {
-    [k in Exclude<KA, KA & KB>]: A[k];
-} & {
-    [k in Exclude<KB, KA & KB>]: B[k];
-} & {
-    [k in KA & KB]: A[k] | B[k];
-})) : never) : never : never;
-export declare namespace Merge {
-    type JoinProps<A, B> = A extends NonComposableTypes ? B : (B extends NonComposableTypes ? A : A & B);
-}
-/**
-* Left join `a` with `b`.
-*
-* This returns the proper type of `{ ...a, ...b }`
-*
-* @example
-* ```ts
-* leftJoin({ a: 1 }, {} as { a?: string | undefined }) // { a: number | string }
-* ```
-*/
-export declare function merge<A, B>(a: A, b: B): Merge<A, B>;
-//# sourceMappingURL=merge.d.ts.map

package/esm/merge.d.ts.map

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

package/esm/merge.js

@@ -1,14 +0,0 @@
-/**
-* Left join `a` with `b`.
-*
-* This returns the proper type of `{ ...a, ...b }`
-*
-* @example
-* ```ts
-* leftJoin({ a: 1 }, {} as { a?: string | undefined }) // { a: number | string }
-* ```
-*/
-export function merge(a, b) {
-    return { ...a, ...b };
-}
-//# sourceMappingURL=merge.js.map

package/esm/merge.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge.js","sourceRoot":"","sources":["../ts/merge.ts"],"names":[],"mappings":"AA2DA;;;;;;;;;EASE;AACF,MAAM,UAAU,KAAK,CAAO,CAAI,EAAE,CAAI;IACrC,OAAO,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,EAAS,CAAA;AAC7B,CAAC"}

package/esm/mix_types/any_or_never_type.d.ts

@@ -1,37 +0,0 @@
-import type { AnyType } from '../any/any_type.js';
-import type { NeverType } from '../never/never_type.js';
-/**
- * Parse `T` to ensure it is either exactly `any` or exactly `never`.
- *
- * 🌪️ *filter*
- * 🩳 *shortcut*
- *
- * @example
- * ```ts
- * type R = AnyOrNeverType<any> // any
- * type R = AnyOrNeverType<never> // never
- * type R = AnyOrNeverType<never, 1, 2> // 1
- *
- * type R = AnyOrNeverType<unknown> // never
- * type R = AnyOrNeverType<unknown, 1, 2> // 2
- * type R = AnyOrNeverType<string | boolean> // never
- * ```
- */
-export type AnyOrNeverType<T, Then = T, Else = never> = NeverType<T, Then, AnyType<T, Then, Else>>;
-/**
- * Validate if `T` is either exactly `any` or exactly `never`.
- *
- * 🎭 *validate*
- * 🩳 *shortcut*
- *
- * @example
- * ```ts
- * type R = IsAnyOrNever<any> // true
- * type R = IsAnyOrNever<never> // true
- *
- * type R = IsAnyOrNever<1> // false
- * type R = IsAnyOrNever<unknown> // false
- * ```
- */
-export type IsAnyOrNever<T, Then = true, Else = false> = NeverType<T, Then, AnyType<T, Then, Else>>;
-//# sourceMappingURL=any_or_never_type.d.ts.map

package/esm/mix_types/any_or_never_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"any_or_never_type.d.ts","sourceRoot":"","sources":["../../ts/mix_types/any_or_never_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAEvD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;AAElG;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA"}

package/esm/mix_types/any_or_never_type.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=any_or_never_type.js.map

package/esm/mix_types/any_or_never_type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"any_or_never_type.js","sourceRoot":"","sources":["../../ts/mix_types/any_or_never_type.ts"],"names":[],"mappings":""}