type-plus 7.6.2 → 8.0.0-beta.10

package/ts/boolean/true_type.ts

@@ -1,53 +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>

package/ts/class/AnyConstructor.ts

@@ -1 +0,0 @@
-export type AnyConstructor<Params extends any[] = any[]> = new (...args: Params) => void

package/ts/class/isConstructor.ts

@@ -1,34 +0,0 @@
-import type { AnyConstructor } from './AnyConstructor.js'
-
-/**
- * Is the subject a constructor function.
- *
- * @deprecated this is not a failsafe test,
- * it will return true for any function that can be called with `new`.
- *
- * If the subject is an arrow function,
- * it can still return true after compilation.
- *
- * Thus this function is not safe to use.
- */
-export function isConstructor(subject: unknown): subject is AnyConstructor {
-	try {
-		new (subject as AnyConstructor)()
-	} catch (err: any) {
-		const msg = err?.message as string | undefined
-		if (msg && msg.indexOf('is not a constructor') >= 0) {
-			return false
-		}
-	}
-	return true
-}
-
-/**
- * instanceof type guard for unknown value.
- */
-export function isInstanceof<T extends AnyConstructor>(
-	subject: unknown,
-	constructor: T
-): subject is InstanceType<T> {
-	return subject instanceof constructor
-}

package/ts/equal/equal.ts

@@ -1,142 +0,0 @@
-import type { IsAny } from '../any/any_type.js'
-import type { IsNever } from '../never/never_type.js'
-import type { IsObject } from '../object/object_type.js'
-import type { Properties } from '../object/properties.js'
-import type { And, Or } from '../predicates/logical.js'
-import type { IsSymbol } from '../symbol/symbol_type.js'
-
-type BothNever<A, B, Both, One, None> = And<
-	IsNever<A>,
-	IsNever<B>,
-	Both,
-	Or<IsNever<A>, IsNever<B>, One, None>
->
-
-type BothAny<A, B, Both, One, None> = And<IsAny<A>, IsAny<B>, Both, Or<IsAny<A>, IsAny<B>, One, None>>
-
-type IdentityEqual<A, B, Then, Else> = (<_>() => _ extends (A & _) | _ ? 1 : 2) extends <_>() => _ extends
-	| (B & _)
-	| _
-	? 1
-	: 2
-	? Then
-	: Else
-
-/**
- * Checks `A` and `B` are equal.
- *
- * ```ts
- * type R = IsEqual<1, 1> // true
- * type R = IsEqual<any, any> // true
- * type R = IsEqual<boolean, boolean> // true
- * type R = IsEqual<true, true> // true
- * type R = IsEqual<[1], [1]> // true
- *
- * type R = IsEqual<boolean, true> // false
- * type R = IsEqual<any, 1> // false
- * type R = IsEqual<[any], [1]> // false
- * type R = IsEqual<{ a: 1 }, { a: 1; b: 2 }> // false
- * ```
- *
- * Note that intersection type checks only works at first level.
- * It cannot be check recursively,
- * or else will run into infinite recursion if the type includes recursive types.
- */
-export type IsEqual<A, B, Then = true, Else = false> = [A, B] extends [B, A]
-	? BothNever<
-			A,
-			B,
-			Then,
-			Else,
-			BothAny<
-				A,
-				B,
-				Then,
-				Else,
-				IdentityEqual<
-					A,
-					B,
-					Then,
-					And<
-						IsObject<A>,
-						IsObject<B>,
-						IdentityEqual<
-							Properties<A>,
-							Properties<B>,
-							[A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
-								? IsEqual<P1, P2, Then, Else>
-								: Then,
-							Else
-						>,
-						// `A` and `B` are narrowed, need to check again.
-						// This is fixed in TS 5.0.2, but keeping it to support older versions.
-						[A, B] extends [B, A] ? Then : Else
-					>
-				>
-			>
-	  >
-	: And<IsSymbol<A>, IsSymbol<B>, Then, Else>
-
-/**
- * Checks `A` and `B` are not equal.
- *
- * ```ts
- * type R = IsNotEqual<1, 1> // false
- * type R = IsNotEqual<any, any> // false
- * type R = IsNotEqual<boolean, boolean> // false
- * type R = IsNotEqual<true, true> // false
- * type R = IsNotEqual<[1], [1]> // false
- *
- * type R = IsNotEqual<boolean, true> // true
- * type R = IsNotEqual<any, 1> // true
- * type R = IsNotEqual<[any], [1]> // true
- * type R = IsNotEqual<{ a: 1 }, { a: 1; b: 2 }> // true
- * ```
- *
- * Note that intersection type checks only works at first level.
- * It cannot be check recursively,
- * or else will run into infinite recursion if the type includes recursive types.
- */
-export type IsNotEqual<A, B, Then = true, Else = false> = IsEqual<A, B, Else, Then>
-
-/**
- * Checks `A` and `B` are equal.
- *
- * @deprecated this will be changed to `filter` variant in the future.
- * Please use `IsEqual` for the `predicate` behavior.
- *
- * ```ts
- * type R = Equal<1, 1> // true
- * type R = Equal<any, any> // true
- * type R = Equal<boolean, boolean> // true
- * type R = Equal<true, true> // true
- * type R = Equal<[1], [1]> // true
- *
- * type R = Equal<boolean, true> // false
- * type R = Equal<any, 1> // false
- * type R = Equal<[any], [1]> // false
- * type R = Equal<{ a: 1 }, { a: 1; b: 2 }> // false
- * ```
- */
-export type Equal<A, B, Then = true, Else = false> = IsEqual<A, B, Then, Else>
-
-/**
- * Checks `A` and `B` are not equal.
- *
- * @deprecated this will be changed to `filter` variant in the future.
- * Please use `IsNotEqual` for the `predicate` behavior.
- *
- * ```ts
- * type R = NotEqual<1, 1> // false
- * type R = NotEqual<any, any> // false
- * type R = NotEqual<boolean, boolean> // false
- * type R = NotEqual<true, true> // false
- * type R = NotEqual<[1], [1]> // false
- *
- * type R = NotEqual<boolean, true> // true
- * type R = NotEqual<any, 1> // true
- * type R = NotEqual<[any], [1]> // true
- * type R = NotEqual<{ a: 1 }, { a: 1; b: 2 }> // true
- * ```
- */
-export type NotEqual<A, B, Then = true, Else = false> = IsNotEqual<A, B, Then, Else>

package/ts/equal/readme.md

@@ -1,48 +0,0 @@
-# IsEqual
-
-`IsEqual<A, B>` and friends check if `A` and `B` are equal.
-
-It is a type-level version of `===`.
-It handles special types (`any`, `unknown`, `never`, `void`) correctly.
-
-```ts
-import { type IsEqual } from 'type-plus'
-
-type R = IsEqual<1, 1> // true
-type R = IsEqual<any, any> // true
-type R = IsEqual<boolean, boolean> // true
-type R = IsEqual<true, true> // true
-type R = IsEqual<[1], [1]> // true
-
-type R = IsEqual<boolean, true> // false
-type R = IsEqual<any, 1> // false
-type R = IsEqual<[any], [1]> // false
-type R = IsEqual<{ a: 1 }, { a: 1; b: 2 }> // false
-```
-
-Note that intersection type checks only works at first level.
-It cannot be check recursively,
-or else will run into infinite recursion if the type includes recursive types.
-
-i.e.
-
-```ts
-// true
-IsEqual<{ a: 1 } & { b: 2 }, { a: 1; b: 2 }>
-
-// false
-IsEqual<{ nested: { a: number; b: string } }, { nested: { a: number } & { b: string } }>
-```
-
-- [`IsEqual<A, B, Then = true, Else = false>`](equal.ts#L27): check if `A` and `B` are equal.
-- [`IsNotEqual<A, B, Then = true, Else = false>`](equal.ts#L88): check if `A` and `B` are not equal.
-
----
-
-[![Just Code: Equality is hard][equality-is-hard]][equality-is-hard-url]
-[![Just Code: Equality is hard part 2][equality-is-hard-2]][equality-is-hard-2-url]
-
-[equality-is-hard]: https://img.youtube.com/vi/VEqrFzCzo28/0.jpg
-[equality-is-hard-url]: https://www.youtube.com/watch?v=VEqrFzCzo28
-[equality-is-hard-2]: https://img.youtube.com/vi/l6G6Rz1n9Sw/0.jpg
-[equality-is-hard-2-url]: https://www.youtube.com/watch?v=l6G6Rz1n9Sw

package/ts/function/extract_function.ts

@@ -1,29 +0,0 @@
-import type { AnyFunction } from './any_function.js'
-
-/**
- * Extract the function signature from a composite type T.
- *
- * It works with interact of functions, but not on function overloads and union.
- * @note does not work with function overloads.
- *
- * ```ts
- * import type { ExtractFunction } from 'type-plus'
- *
- * type R = ExtractFunction<{
- *   () => void
- *   a: 1
- * }> // () => void
- * ```
- */
-export type ExtractFunction<T extends AnyFunction> = T extends AnyFunction<infer P, infer R>
-	? (...args: P) => R
-	: never
-
-/**
- * Extract the function signature from a composite function.
- *
- * @note does not work with function overloads.
- */
-export function extractFunction<T extends AnyFunction>(fn: T) {
-	return fn as unknown as ExtractFunction<T>
-}

package/ts/function/function_type.ts

@@ -1,64 +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>

package/ts/function/strict_function_type.ts

@@ -1,53 +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>

package/ts/functional/Maybe.ts

@@ -1,22 +0,0 @@
-import type { Brand } from '../nominal/index.js'
-import type { IsEqual } from '../equal/equal.js'
-import type { Widen } from '../utils/index.js'
-
-export type Maybe<T> = Just<T> | None<T>
-export type Just<T> = Brand<'maybe', T> & { unwrap(): T }
-export type None<T> = Brand<'maybe', void> & { unwrap(): T }
-
-export function just<T>(
-	value: T
-): IsEqual<T, undefined | null> extends true ? None<T> : Just<Widen<NonNullable<T>>> {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-	return {
-		unwrap() {
-			return value
-		}
-	} as any
-}
-
-export function none<T>(): None<T> {
-	return { unwrap() {} } as None<T>
-}

package/ts/functional/compose.ts

@@ -1,17 +0,0 @@
-import type { Head } from '../array/head.js'
-import type { Last } from '../array/last.js'
-import type { AnyFunction } from '../function/any_function.js'
-
-/**
- * Compose functions to produce a new function.
- * @params args functions to be composed.
- * Each function will receive the return value of the previous function as its parameters.
- * @return The composed function will expect the parameters of the first function,
- * and return the result of the last function.
- */
-export function compose<FS extends AnyFunction[]>(
-	...fns: FS
-): (...args: Parameters<Head<FS>>) => ReturnType<Last<FS>> {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-	return (...args: any[]) => fns.reduce((args, fn) => [fn(...args)], args)[0]
-}

package/ts/functional/context.ts

@@ -1,66 +0,0 @@
-import type { LeftJoin } from '../object/index.js'
-
-export type ContextBaseShape = Record<string | symbol, any>
-
-/**
- * Extends the context with new props.
- * @param context the current context.
- * @return an additional context with new properties.
- */
-export type ContextExtender<Current, Additional> = (context: Current) => Additional
-
-export type ContextBuilder<Init extends ContextBaseShape, Ctx extends ContextBaseShape> = {
-	/**
-	 * Extends the context using an extender.
-	 *
-	 * @type Additional The additional context to be added by the `extender`.
-	 * By default this is inferred by the `extender`.
-	 * But you can also explicitly specify it,
-	 * if the type is a superset of the actual return type of the `extender`.
-	 * @param extender function that add new props to the context.
-	 *
-	 * The extender only need to return a new object with additional properties.
-	 * The builder will merge that with the current context.
-	 *
-	 * If the extender specify an existing property,
-	 * it overrides the existing value.
-	 */
-	extend<Additional extends ContextBaseShape = ContextBaseShape>(
-		extender: ContextExtender<Ctx, Additional>
-	): ContextBuilder<Init, LeftJoin<Ctx, Additional>>,
-	/**
-	 * Build and return the context.
-	 */
-	build(): Ctx
-}
-
-/**
- * Creates a context builder.
- *
- * @param init The initial context or an context initializer.
- * @return the context builder where you can
- * use `extend()` to add context, and
- * use `build()` to build the context.
- */
-export function context<Init extends ContextBaseShape, Ctx extends ContextBaseShape = Init>(
-	init?: Init | (() => Init)
-): ContextBuilder<Init, Ctx> {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-	return typeof init === 'function' ? contextBuilder({}, [[init]]) : (contextBuilder(init ?? {}, []) as any)
-}
-
-/* eslint-disable */
-function contextBuilder(init: ContextBaseShape, extenders: Array<[ContextExtender<any, any> | any]>) {
-	return {
-		extend(extender: ContextExtender<any, any>) {
-			return contextBuilder(init, extenders.concat([[extender]]))
-		},
-		build() {
-			return extenders.reduce((p, [t], i) => {
-				const v = typeof t === 'function' ? (extenders[i]![0] = t(p)) : t
-				return { ...p, ...v }
-			}, init)
-		}
-	}
-}
-/* eslint-enable */

package/ts/index.ts

@@ -1,121 +0,0 @@
-export type { AnyType, IsAny, IsNotAny, NotAnyType } from './any/any_type.js'
-export type { At } from './array/array.at.js'
-export type { FindLast } from './array/array.find_last.js'
-export type { Some } from './array/array.some.js'
-export type { Concat } from './array/array_plus.concat.js'
-export * as ArrayPlus from './array/array_plus.js'
-export type { ArrayType, IsArray, IsNotArray, NotArrayType } from './array/array_type.js'
-export type { Filter, KeepMatch } from './array/filter.js'
-export type { FindFirst } from './array/find_first.js'
-export type { Head } from './array/head.js'
-export type { IntersectOfProps, MapToProp } from './array/intersect_of_props.js'
-export type { Last } from './array/last.js'
-export { literalArray } from './array/literal_array.js'
-export type { PadStart } from './array/pad_start.js'
-export { reduceWhile } from './array/reduce_while.js'
-export type { Reverse } from './array/reverse.js'
-export type { PropUnion, UnionOfProps } from './array/union_of_props.js'
-export type { UnionOfValues } from './array/union_of_values.js'
-export { assertType } from './assertion/assert_type.js'
-export type { BigintType, IsBigint, IsNotBigint, NotBigintType } from './bigint/bigint_type.js'
-export type { StringToBigint } from './bigint/cast.js'
-export type {
-	IsNotStrictBigint,
-	IsStrictBigint,
-	NotStrictBigintType,
-	StrictBigintType
-} from './bigint/strict_bigint_type.js'
-export type { BooleanType, IsBoolean, IsNotBoolean, NotBooleanType } from './boolean/boolean_type.js'
-export type { FalseType, IsFalse, IsNotFalse, NotFalseType } from './boolean/false_type.js'
-export type {
-	IsNotStrictBoolean,
-	IsStrictBoolean,
-	NotStrictBooleanType,
-	StrictBooleanType
-} from './boolean/strict_boolean_type.js'
-export type { IsNotTrue, IsTrue, NotTrueType, TrueType } from './boolean/true_type.js'
-export * from './class/index.js'
-export type { ComposableTypes, NonComposableTypes } from './composable_types.js'
-export type { Equal, IsEqual, IsNotEqual, NotEqual } from './equal/equal.js'
-export type { AnyFunction } from './function/any_function.js'
-export * from './function/extract_function.js'
-export type { FunctionType, IsFunction, IsNotFunction, NotFunctionType } from './function/function_type.js'
-export type {
-	IsNotStrictFunction,
-	IsStrictFunction,
-	NotStrictFunctionType,
-	StrictFunctionType
-} from './function/strict_function_type.js'
-export * from './functional/index.js'
-export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './json.js'
-export type { Abs, Add, Decrement, GreaterThan, Increment, Max, Multiply, Subtract } from './math/index.js'
-export * as MathPlus from './math/math_plus.js'
-export type { AnyOrNeverType, IsAnyOrNever } from './mix_types/any_or_never_type.js'
-export type { IsNever, IsNotNever, Is_Never, NeverType, NotNeverType, Not_Never } from './never/never_type.js'
-export * from './nodejs/index.js'
-export * from './nominal/index.js'
-export type { IsNotNull, IsNull, NotNullType, NullType } from './null/null_type.js'
-export type { StringToNumber } from './number/cast.js'
-export * as NumberPlus from './number/number_plus.js'
-export type { IsNotNumber, IsNumber, NotNumberType, NumberType } from './number/number_type.js'
-export type {
-	IsNotStrictNumber,
-	IsStrictNumber,
-	NotStrictNumberType,
-	StrictNumberType
-} from './number/strict_number_type.js'
-export type { NumericToString, StringToNumeric } from './numeric/cast.js'
-export type { Integer, IsInteger, IsNotInteger, IsWhole, NotInteger } from './numeric/integer.js'
-export type { IsNegative, IsNotNegative, Negative, NotNegative } from './numeric/negative.js'
-export * as NumericPlus from './numeric/numeric_plus.js'
-export type {
-	IsNotNumeric,
-	IsNumeric,
-	NotNumericType,
-	Numeric,
-	NumericType,
-	Zero
-} from './numeric/numeric_type.js'
-export type { IsNotPositive, IsPositive, NonPositive, Positive } from './numeric/positive.js'
-export type { Required, RequiredExcept, RequiredPick } from './object/Required.js'
-export * from './object/index.js'
-export type { IsNotObject, IsObject, NotObjectType, ObjectType } from './object/object_type.js'
-export * from './predicates/index.js'
-export type { PrimitiveTypes } from './primitive.js'
-export * from './promise/index.js'
-export type {
-	IsNotStrictString,
-	IsStrictString,
-	NotStrictStringType,
-	StrictStringType
-} from './string/strict_string_type.js'
-export type { StringIncludes, StringSplit } from './string/string.js'
-export type { StringPlus } from './string/string_plus.js'
-export type { IsNotString, IsString, NotStringType, StringType } from './string/string_type.js'
-export type { IsNotSymbol, IsSymbol, NotSymbolType, SymbolType } from './symbol/symbol_type.js'
-export * from './testing/stub.js'
-export * from './testing/test_type.js'
-export type { CommonKeys, CommonPropKeys } from './tuple/common_prop_keys.js'
-export * from './tuple/create_tuple.js'
-export { drop } from './tuple/drop.js'
-export type { DropFirst, DropLast, DropMatch, DropNull, DropNullable, DropUndefined } from './tuple/drop.js'
-export type { Tail } from './tuple/tail.js'
-export * as TuplePlus from './tuple/tuple_plus.js'
-export type { IsNotTuple, IsTuple, NotTupleType, TupleType } from './tuple/tuple_type.js'
-export * from './type-guard/is_type.js'
-export type { Failed, FailedT } from './type/failed.js'
-export type { NoInfer } from './type/no_infer.js'
-export type {
-	IsNotUndefined,
-	IsUndefined,
-	NotUndefinedType,
-	UndefinedType
-} from './undefined/undefined_type.js'
-export type { IsUnion, UnionType } from './union/union.js'
-export type { UnionKeys } from './union_keys.js'
-export type { IsNotUnknown, IsUnknown, NotUnknownType, UnknownType } from './unknown/unknown_type.js'
-export * from './unpartial.js'
-export * from './utils/index.js'
-export type { MergeOptions as MergeCases } from './utils/options.js'
-export type { IsNotVoid, IsVoid, NotVoidType, VoidType } from './void/void_type.js'
-

package/ts/json.ts

@@ -1,17 +0,0 @@
-export type JSONTypes = JSONPrimitive | JSONObject | JSONArray
-
-export type JSONPrimitive = boolean | number | string | null
-
-export type JSONObject = { [key in string]?: JSONTypes }
-
-export type JSONArray = Array<JSONTypes>
-
-export const JSONTypes = { get }
-
-function get<T extends JSONTypes>(obj: JSONTypes, ...props: Array<string | number>): T | undefined {
-	if (props.length === 0) return obj as T
-	if (typeof obj !== 'object' || obj === null) return undefined
-	const p = props.shift()!
-	// @ts-ignore
-	return get(obj[p], ...props) as T
-}