type-plus 8.0.0-beta.2 → 8.0.0-beta.4

package/cjs/undefined/has_undefined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has_undefined.d.ts","sourceRoot":"","sources":["../../src/undefined/has_undefined.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAA;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,EAAE,SAAS,iBAAiB,GAAG,EAAE,IAAI,cAAc,CAC9E,CAAC,EACD,EAAE,EACF;IAAC,WAAW,CAAC,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,KAAK;CAAC,CAC9C,CAAA"}

package/cjs/undefined/has_undefined.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=has_undefined.js.map

package/cjs/undefined/has_undefined.js.map

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

package/cjs/undefined/is_not_undefined.d.ts

@@ -0,0 +1,72 @@
+import type { NotAssignable } from '../predicates/not_assignable.js';
+import type { $Equality } from '../type_plus/$equality.js';
+import type { $MergeOptions } from '../type_plus/$merge_options.js';
+import type { $SpecialType } from '../type_plus/$special_type.js';
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js';
+import type { $Then } from '../type_plus/branch/$selection.js';
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is not `undefined`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotUndefined<undefined> // false
+ *
+ * type R = IsNotUndefined<never> // true
+ * type R = IsNotUndefined<unknown> // true
+ * type R = IsNotUndefined<string | boolean> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is not `undefined`, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotUndefined<undefined, { selection: 'filter' }> // never
+ *
+ * type R = IsNotUndefined<never, { selection: 'filter' }> // never
+ * type R = IsNotUndefined<unknown, { selection: 'filter' }> // unknown
+ * type R = IsNotUndefined<string | boolean, { selection: 'filter' }> // string | boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Disable distribution of union types.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotUndefined<undefined | 1> // boolean
+ * type R = IsNotUndefined<undefined | 1, { distributive: false }> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotUndefined<string, $SelectionBranch> // $Then
+ * type R = IsNotUndefined<undefined, $SelectionBranch> // $Else
+ * ```
+ */
+export type IsNotUndefined<T, $O extends IsNotUndefined.$Options = {}> = $SpecialType<T, $MergeOptions<$O, {
+    $then: $ResolveBranch<T, $O, [$Then]>;
+    $else: IsNotUndefined.$<T, $O>;
+}>>;
+export declare namespace IsNotUndefined {
+    type $Options = $Equality.$Options;
+    type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>;
+    /**
+     * 🧰 *type util*
+     *
+     * Validate if `T` is `undefined`.
+     *
+     * This is a type util for building custom types.
+     * It does not check against special types.
+     */
+    type $<T, $O extends $UtilOptions> = NotAssignable.$<T, undefined, $O>;
+    type $UtilOptions = NotAssignable.$UtilOptions;
+}
+//# sourceMappingURL=is_not_undefined.d.ts.map

package/cjs/undefined/is_not_undefined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_not_undefined.d.ts","sourceRoot":"","sources":["../../src/undefined/is_not_undefined.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,EAAE,SAAS,cAAc,CAAC,QAAQ,GAAG,EAAE,IAAI,YAAY,CACpF,CAAC,EACD,aAAa,CACZ,EAAE,EACF;IACC,KAAK,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;IACrC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;CAC9B,CACD,CACD,CAAA;AAED,yBAAiB,cAAc,CAAC;IAC/B,KAAY,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAA;IACzC,KAAY,OAAO,CAAC,EAAE,SAAS,QAAQ,GAAG,EAAE,IAAI,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAErE;;;;;;;OAOG;IACH,KAAY,CAAC,CAAC,CAAC,EAAE,EAAE,SAAS,YAAY,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC,CAAA;IAC7E,KAAY,YAAY,GAAG,aAAa,CAAC,YAAY,CAAA;CACrD"}

package/cjs/undefined/is_not_undefined.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=is_not_undefined.js.map

package/cjs/undefined/is_not_undefined.js.map

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

package/cjs/undefined/is_undefined.d.ts

@@ -0,0 +1,75 @@
+import type { Assignable } from '../predicates/assignable.js';
+import type { $Equality } from '../type_plus/$equality.js';
+import type { $MergeOptions } from '../type_plus/$merge_options.js';
+import type { $SpecialType } from '../type_plus/$special_type.js';
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js';
+import type { $Else } from '../type_plus/branch/$selection.js';
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is `undefined`.
+ *
+ * @example
+ * ```ts
+ * type R = IsUndefined<undefined> // true
+ *
+ * type R = IsUndefined<never> // false
+ * type R = IsUndefined<unknown> // false
+ * type R = IsUndefined<string | boolean> // false
+ *
+ * type R = IsUndefined<string | undefined> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is `undefined`, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsUndefined<undefined, { selection: 'filter' }> // undefined
+ *
+ * type R = IsUndefined<never, { selection: 'filter' }> // never
+ * type R = IsUndefined<unknown, { selection: 'filter' }> // never
+ * type R = IsUndefined<string | boolean, { selection: 'filter' }> // never
+ *
+ * type R = IsUndefined<string | undefined> // undefined
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = IsUndefined<undefined | 1> // boolean
+ * type R = IsUndefined<undefined | 1, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsUndefined<undefined, $SelectionBranch> // $Then
+ * type R = IsUndefined<string, $SelectionBranch> // $Else
+ * ```
+ */
+export type IsUndefined<T, $O extends IsUndefined.$Options = {}> = $SpecialType<T, $MergeOptions<$O, {
+    $then: $ResolveBranch<T, $O, [$Else]>;
+    $else: IsUndefined.$<T, $O>;
+}>>;
+export declare namespace IsUndefined {
+    type $Options = $Equality.$Options;
+    type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>;
+    /**
+     * 🧰 *type util*
+     *
+     * Validate if `T` is `undefined`.
+     *
+     * This is a type util for building custom types.
+     * It does not check against special types.
+     */
+    type $<T, $O extends $UtilOptions> = Assignable.$<T, undefined, $O>;
+    type $UtilOptions = Assignable.$UtilOptions;
+}
+//# sourceMappingURL=is_undefined.d.ts.map

package/cjs/undefined/is_undefined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_undefined.d.ts","sourceRoot":"","sources":["../../src/undefined/is_undefined.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,EAAE,SAAS,WAAW,CAAC,QAAQ,GAAG,EAAE,IAAI,YAAY,CAC9E,CAAC,EACD,aAAa,CACZ,EAAE,EACF;IACC,KAAK,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;IACrC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;CAC3B,CACD,CACD,CAAA;AAED,yBAAiB,WAAW,CAAC;IAC5B,KAAY,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAA;IACzC,KAAY,OAAO,CAAC,EAAE,SAAS,QAAQ,GAAG,EAAE,IAAI,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAErE;;;;;;;OAOG;IACH,KAAY,CAAC,CAAC,CAAC,EAAE,EAAE,SAAS,YAAY,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC,CAAA;IAC1E,KAAY,YAAY,GAAG,UAAU,CAAC,YAAY,CAAA;CAClD"}

package/cjs/undefined/is_undefined.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=is_undefined.js.map

package/cjs/undefined/is_undefined.js.map

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

package/cjs/union/union.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 🌪️ *filter*
+ *
+ * Filter the type `T` to ensure it is a union.
+ *
+ * @example
+ * ```ts
+ * type R = IsUnion<'a' | 'b'> // 'a' | 'b'
+ * type R = IsUnion<boolean> // boolean
+ * type R = IsUnion<number> // never
+ * ```
+ */
+export type UnionType<T, Then = T, Else = never> = UnionType.Device<T, Then, Else>;
+/**
+ * 🎭 *predicate*
+ *
+ * Validate the type `T` is a union.
+ *
+ * @author Nurbol Alpysbayev
+ * @see https://stackoverflow.com/questions/53953814/typescript-check-if-a-type-is-a-union
+ *
+ * @example
+ * ```ts
+ * type R = IsUnion<'a' | 'b'> // true
+ * type R = IsUnion<boolean> // true
+ * type R = IsUnion<number> // false
+ * ```
+ */
+export type IsUnion<T, Then = true, Else = false> = UnionType.Device<T, Then, Else>;
+export declare namespace UnionType {
+    type Device<T, Then, Else, U = T> = (T extends unknown ? (U extends T ? 1 : 2) : never) extends 1 ? Else : Then;
+}
+//# sourceMappingURL=union.d.ts.map

package/cjs/union/union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../src/union/union.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAElF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEnF,yBAAiB,SAAS,CAAC;IAC1B,KAAY,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,SAAS,OAAO,GAAG,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,GAAG,IAAI,GAAG,IAAI,CAAA;CACtH"}

package/cjs/union/union.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=union.js.map

package/cjs/union/union.js.map

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

package/cjs/union/union_to_intersection.d.ts

@@ -0,0 +1,3 @@
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export declare function toIntersection<U>(union: U): UnionToIntersection<U>;
+//# sourceMappingURL=union_to_intersection.d.ts.map

package/cjs/union/union_to_intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union_to_intersection.d.ts","sourceRoot":"","sources":["../../src/union/union_to_intersection.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,IAAI,GAAG,CAAC,GAAG,KAAK,CAAA;AAEtH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAElE"}

package/cjs/union/union_to_intersection.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toIntersection = toIntersection;
+function toIntersection(union) {
+    return union;
+}
+//# sourceMappingURL=union_to_intersection.js.map

package/cjs/union/union_to_intersection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union_to_intersection.js","sourceRoot":"","sources":["../../src/union/union_to_intersection.ts"],"names":[],"mappings":";;AAIA,wCAEC;AAFD,SAAgB,cAAc,CAAI,KAAQ;IACzC,OAAO,KAAsC,CAAA;AAC9C,CAAC"}

package/cjs/union_keys.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `UnionKeys<T>` will distribute keys of an union to individual types.
+ * This should be used in conjuncture with distributive types.
+ */
+export type UnionKeys<T> = keyof T | (T extends unknown ? keyof T : never);
+//# sourceMappingURL=union_keys.d.ts.map

package/cjs/union_keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union_keys.d.ts","sourceRoot":"","sources":["../src/union_keys.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,OAAO,GAAG,MAAM,CAAC,GAAG,KAAK,CAAC,CAAA"}

package/cjs/union_keys.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=union_keys.js.map

package/cjs/union_keys.js.map

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

package/cjs/unknown/is_not_unknown.d.ts

@@ -0,0 +1,53 @@
+import type { $Any } from '../any/any.js';
+import type { $Never } from '../never/never.js';
+import type { $SpecialType } from '../type_plus/$special_type.js';
+import type { $InputOptions } from '../type_plus/branch/$input_options.js';
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js';
+import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$selection.js';
+import type { $SelectionOptions } from '../type_plus/branch/$selection_options.js';
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is not exactly `unknown`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotUnknown<unknown> // false
+ *
+ * type R = IsNotUnknown<number> // true
+ * type R = IsNotUnknown<never> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is not exactly `unknown`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotUnknown<unknown, { selection: 'filter' }> // never
+ *
+ * type R = IsNotUnknown<number, { selection: 'filter' }> // number
+ * type R = IsNotUnknown<never, { selection: 'filter' }> // never
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotUnknown<unknown, $SelectionBranch> // $Else
+ * type R = IsNotUnknown<string, $SelectionBranch> // $Then
+ * ```
+ */
+export type IsNotUnknown<T, $O extends IsNotUnknown.$Options = {}> = $SpecialType<T, {
+    $any: $ResolveBranch<T, $O, [$Any, $Then]>;
+    $unknown: $ResolveBranch<T, $O, [$Else]>;
+    $never: $ResolveBranch<T, $O, [$Never, $Then]>;
+    $else: $ResolveBranch<T, $O, [$Then]>;
+}>;
+export declare namespace IsNotUnknown {
+    type $Options = $SelectionOptions & $InputOptions<$Any | $Never>;
+    type $Branch = $SelectionBranch;
+}
+//# sourceMappingURL=is_not_unknown.d.ts.map

package/cjs/unknown/is_not_unknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_not_unknown.d.ts","sourceRoot":"","sources":["../../src/unknown/is_not_unknown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAA;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AACvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAA;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,EAAE,SAAS,YAAY,CAAC,QAAQ,GAAG,EAAE,IAAI,YAAY,CAChF,CAAC,EACD;IACC,IAAI,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAA;IAC1C,QAAQ,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;IACxC,MAAM,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;IAC9C,KAAK,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;CACrC,CACD,CAAA;AAED,yBAAiB,YAAY,CAAC;IAC7B,KAAY,QAAQ,GAAG,iBAAiB,GAAG,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAA;IACvE,KAAY,OAAO,GAAG,gBAAgB,CAAA;CACtC"}

package/cjs/unknown/is_not_unknown.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=is_not_unknown.js.map

package/cjs/unknown/is_not_unknown.js.map

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

package/cjs/unknown/is_unknown.d.ts

@@ -0,0 +1,53 @@
+import type { $Any } from '../any/any.js';
+import type { $Never } from '../never/never.js';
+import type { $SpecialType } from '../type_plus/$special_type.js';
+import type { $InputOptions } from '../type_plus/branch/$input_options.js';
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js';
+import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$selection.js';
+import type { $SelectionOptions } from '../type_plus/branch/$selection_options.js';
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is exactly `unknown`.
+ *
+ * @example
+ * ```ts
+ * type R = IsUnknown<unknown> // true
+ *
+ * type R = IsUnknown<number> // false
+ * type R = IsUnknown<never> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is exactly `unknown`.
+ *
+ * @example
+ * ```ts
+ * type R = IsUnknown<unknown, { selection: 'filter' }> // unknown
+ *
+ * type R = IsUnknown<number, { selection: 'filter' }> // never
+ * type R = IsUnknown<never, { selection: 'filter' }> // never
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsUnknown<unknown, $SelectionBranch> // $Then
+ * type R = IsUnknown<string, $SelectionBranch> // $Else
+ * ```
+ */
+export type IsUnknown<T, $O extends IsUnknown.$Options = {}> = $SpecialType<T, {
+    $any: $ResolveBranch<T, $O, [$Any, $Else]>;
+    $unknown: $ResolveBranch<T, $O, [$Then]>;
+    $never: $ResolveBranch<T, $O, [$Never, $Else]>;
+    $else: $ResolveBranch<T, $O, [$Else]>;
+}>;
+export declare namespace IsUnknown {
+    type $Options = $SelectionOptions & $InputOptions<$Any | $Never>;
+    type $Branch = $SelectionBranch;
+}
+//# sourceMappingURL=is_unknown.d.ts.map

package/cjs/unknown/is_unknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_unknown.d.ts","sourceRoot":"","sources":["../../src/unknown/is_unknown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAA;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AACvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAA;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,EAAE,SAAS,SAAS,CAAC,QAAQ,GAAG,EAAE,IAAI,YAAY,CAC1E,CAAC,EACD;IACC,IAAI,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAA;IAC1C,QAAQ,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;IACxC,MAAM,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;IAC9C,KAAK,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;CACrC,CACD,CAAA;AAED,yBAAiB,SAAS,CAAC;IAC1B,KAAY,QAAQ,GAAG,iBAAiB,GAAG,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAA;IACvE,KAAY,OAAO,GAAG,gBAAgB,CAAA;CACtC"}

package/cjs/unknown/is_unknown.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=is_unknown.js.map

package/cjs/unknown/is_unknown.js.map

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

package/cjs/unknown/not_unknown_or.d.ts

@@ -0,0 +1,30 @@
+import type { IsUnknown } from './is_unknown.js';
+import type { $Unknown } from './unknown.js';
+/**
+ * 🌪️ *filter*
+ *
+ * Returns `T` if `T` is not `unknown`, otherwise `$Unknown`.
+ *
+ * @example
+ * ```ts
+ * type R = NotUnknownOr<number> // number
+ * type R = NotUnknownOr<unknown> // $Unknown
+ *
+ * // customize
+ * type R = NotUnknownOr<unknown, number> // number
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Replace `unknown` branch with `Replace`.
+ *
+ * @example
+ * ```ts
+ * type R = NotUnknownOr<unknown, number> // number
+ * ```
+ */
+export type NotUnknownOr<T, Else = $Unknown> = IsUnknown<T, {
+    $then: Else;
+    $else: T;
+}>;
+//# sourceMappingURL=not_unknown_or.d.ts.map

package/cjs/unknown/not_unknown_or.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not_unknown_or.d.ts","sourceRoot":"","sources":["../../src/unknown/not_unknown_or.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,QAAQ,IAAI,SAAS,CACvD,CAAC,EACD;IACC,KAAK,EAAE,IAAI,CAAA;IACX,KAAK,EAAE,CAAC,CAAA;CACR,CACD,CAAA"}

package/cjs/unknown/not_unknown_or.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=not_unknown_or.js.map

package/cjs/unknown/not_unknown_or.js.map

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

package/cjs/unknown/unknown.d.ts

@@ -0,0 +1,55 @@
+import type { $Branch } from '../type_plus/branch/$branch.js';
+/**
+ * 🧰 *type util*
+ *
+ * A special branch for `unknown` check to represent the value is `unknown`.
+ */
+export type $Unknown = $Branch<'$unknown'>;
+export declare namespace $Unknown {
+    /**
+     * 🧰 *type util*
+     *
+     * Options for specifically handling the type `unknown`.
+     *
+     * @example
+     * ```ts
+     * type YourType<
+     *   T,
+     *   $Options extends YourType.$Options = YourType.$Default
+     * > = ...
+     *
+     * namespace YourType {
+     *   export type $Options = $Unknown.$Options
+     *   export type $Branch = $Unknown.$Branch
+     * }
+     * ```
+     */
+    type $Options = {
+        $unknown?: unknown;
+    };
+    /**
+     * 🧰 *type util*
+     *
+     * Branch option for specifically handling the type `unknown`.
+     *
+     * Use this to finely customize the behavior of your type.
+     *
+     * ```ts
+     * type YourType<
+     *   T,
+     *   $Options extends YourType.$Options = YourType.$Default
+     * > = ...
+     *
+     * namespace YourType {
+     *   export type $Options = $Unknown.$Options
+     *   export type $Branch = $Unknown.$Branch
+     * }
+     *
+     * type R = YourType<T, YourType.$Branch> extends $Unknown ? HandleUnknown : HandleOthers
+     * ```
+     */
+    type $Branch = {
+        $unknown: $Unknown;
+    };
+}
+//# sourceMappingURL=unknown.d.ts.map

package/cjs/unknown/unknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown.d.ts","sourceRoot":"","sources":["../../src/unknown/unknown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAA;AAE7D;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;AAE1C,yBAAiB,QAAQ,CAAC;IACzB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAY,QAAQ,GAAG;QACtB,QAAQ,CAAC,EAAE,OAAO,CAAA;KAClB,CAAA;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,KAAY,OAAO,GAAG;QACrB,QAAQ,EAAE,QAAQ,CAAA;KAClB,CAAA;CACD"}

package/cjs/unknown/unknown.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=unknown.js.map

package/cjs/unknown/unknown.js.map

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

package/cjs/unpartial.d.ts

@@ -0,0 +1,2 @@
+export { required, requiredDeep, unpartial } from 'unpartial';
+//# sourceMappingURL=unpartial.d.ts.map

package/cjs/unpartial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unpartial.d.ts","sourceRoot":"","sources":["../src/unpartial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA"}

package/cjs/unpartial.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpartial = exports.requiredDeep = exports.required = void 0;
+var unpartial_1 = require("unpartial");
+Object.defineProperty(exports, "required", { enumerable: true, get: function () { return unpartial_1.required; } });
+Object.defineProperty(exports, "requiredDeep", { enumerable: true, get: function () { return unpartial_1.requiredDeep; } });
+Object.defineProperty(exports, "unpartial", { enumerable: true, get: function () { return unpartial_1.unpartial; } });
+//# sourceMappingURL=unpartial.js.map

package/cjs/unpartial.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unpartial.js","sourceRoot":"","sources":["../src/unpartial.ts"],"names":[],"mappings":";;;AAAA,uCAA6D;AAApD,qGAAA,QAAQ,OAAA;AAAE,yGAAA,YAAY,OAAA;AAAE,sGAAA,SAAS,OAAA"}

package/cjs/utils/Widen.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Widen scalar types from literals to their parent types.
+ * Borrow from `typical`
+ */
+export type Widen<T> = T extends boolean ? boolean : T extends number ? number : T extends string ? string : T;
+//# sourceMappingURL=Widen.d.ts.map

package/cjs/utils/Widen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Widen.d.ts","sourceRoot":"","sources":["../../src/utils/Widen.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,GAAG,OAAO,GAAG,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,CAAC,CAAA"}

package/cjs/utils/Widen.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Widen.js.map

package/cjs/utils/Widen.js.map

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

package/cjs/utils/as.d.ts

@@ -0,0 +1,10 @@
+export declare function as<T>(subject: unknown): T;
+export declare function asAny(subject: unknown): any;
+/**
+ * amend `subject` with type `T`
+ */
+export declare function amend<S>(subject: S): {
+    union<T>(): T & S;
+    intersect<T>(): T | S;
+};
+//# sourceMappingURL=as.d.ts.map

package/cjs/utils/as.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"as.d.ts","sourceRoot":"","sources":["../../src/utils/as.ts"],"names":[],"mappings":"AAAA,wBAAgB,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,CAAC,CAEzC;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,GAAG,CAE3C;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;UAE3B,CAAC,KAAK,CAAC,GAAG,CAAC;cAGP,CAAC,KAAK,CAAC,GAAG,CAAC;EAItB"}

package/cjs/utils/as.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.as = as;
+exports.asAny = asAny;
+exports.amend = amend;
+function as(subject) {
+    return subject;
+}
+function asAny(subject) {
+    return subject;
+}
+/**
+ * amend `subject` with type `T`
+ */
+function amend(subject) {
+    return {
+        union() {
+            return subject;
+        },
+        intersect() {
+            return subject;
+        },
+    };
+}
+//# sourceMappingURL=as.js.map

package/cjs/utils/as.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"as.js","sourceRoot":"","sources":["../../src/utils/as.ts"],"names":[],"mappings":";;AAAA,gBAEC;AAED,sBAEC;AAKD,sBASC;AApBD,SAAgB,EAAE,CAAI,OAAgB;IACrC,OAAO,OAAY,CAAA;AACpB,CAAC;AAED,SAAgB,KAAK,CAAC,OAAgB;IACrC,OAAO,OAAO,CAAA;AACf,CAAC;AAED;;GAEG;AACH,SAAgB,KAAK,CAAI,OAAU;IAClC,OAAO;QACN,KAAK;YACJ,OAAO,OAAgB,CAAA;QACxB,CAAC;QACD,SAAS;YACR,OAAO,OAAgB,CAAA;QACxB,CAAC;KACD,CAAA;AACF,CAAC"}