type-plus 7.6.2 → 8.0.0-beta.2

package/src/assertion/assert_type.ts

@@ -0,0 +1,117 @@
+import { tersify } from 'tersify'
+import { isConstructor, type AnyConstructor } from '../class/index.js'
+import type { AnyFunction } from '../function/any_function.js'
+
+/**
+ * 💥 *immediate*
+ * 🚦 *assertion*
+ *
+ * Assert the subject satisfies the specified type T
+ * @type T the type to check against.
+ */
+export function assertType<T>(subject: T): asserts subject is T
+export function assertType<T>(subject: unknown, validator: (s: T) => boolean): asserts subject is T
+/**
+ * @deprecated this is not a failsafe test
+ */
+export function assertType<T extends new (..._args: any[]) => any>(
+	subject: unknown,
+	classConstructor: T
+): asserts subject is InstanceType<T>
+export function assertType(subject: unknown, validator?: (s: any) => boolean) {
+	if (validator) {
+		if ((isConstructor(validator) && !(subject instanceof validator)) || !validator(subject))
+			throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
+	}
+	return
+}
+
+assertType.isUndefined = (subject: undefined): asserts subject is undefined => {
+	if (typeof subject !== 'undefined') throw TypeError('subject is not undefined')
+}
+assertType.noUndefined = <S>(subject: Exclude<S, undefined>): void => {
+	if (typeof subject === 'undefined') throw TypeError('subject is undefined')
+}
+
+assertType.isNull = (subject: null): asserts subject is null => {
+	if (subject !== null) throw TypeError('subject is not null')
+}
+assertType.noNull = <S>(subject: Exclude<S, null>): void => {
+	if (subject === null) throw TypeError('subject is null')
+}
+
+assertType.isNumber = (subject: number): asserts subject is number => {
+	if (typeof subject !== 'number') throw TypeError('subject is not number')
+}
+assertType.noNumber = <S>(subject: Exclude<S, number>): void => {
+	if (typeof subject === 'number') throw TypeError('subject is number')
+}
+
+assertType.isBoolean = (subject: boolean): asserts subject is boolean => {
+	if (typeof subject !== 'boolean') throw TypeError('subject is not boolean')
+}
+assertType.noBoolean = <S>(subject: Exclude<S, boolean>): void => {
+	if (typeof subject === 'boolean') throw TypeError('subject is boolean')
+}
+
+assertType.isTrue = (subject: true): asserts subject is true => {
+	if (subject !== true) throw TypeError('subject is not true')
+}
+assertType.noTrue = <S>(subject: Exclude<S, true>): void => {
+	// @ts-ignore
+	if (subject === true) throw TypeError('subject is true')
+}
+
+assertType.isFalse = (subject: false): asserts subject is false => {
+	if (subject !== false) throw TypeError('subject is not false')
+}
+assertType.noFalse = <S>(subject: Exclude<S, false>): void => {
+	// @ts-ignore
+	if (subject === false) throw TypeError('subject is false')
+}
+
+assertType.isString = (subject: string): asserts subject is string => {
+	if (typeof subject !== 'string') throw TypeError('subject is not string')
+}
+assertType.noString = <S>(subject: Exclude<S, string>): void => {
+	if (typeof subject === 'string') throw TypeError('subject is string')
+}
+
+assertType.isFunction = (subject: AnyFunction): asserts subject is AnyFunction => {
+	if (typeof subject !== 'function') throw TypeError('subject is not function')
+}
+assertType.noFunction = <S>(subject: Exclude<S, AnyFunction>): void => {
+	if (typeof subject === 'function') throw TypeError('subject is function')
+}
+
+/**
+ * 💀 deprecated. It does not work in all cases.
+ *
+ * It passes for function that can be called with `new`.
+ * If the subject is an arrow function, it can still return true after compilation.
+ */
+assertType.isConstructor = (subject: AnyConstructor): asserts subject is AnyConstructor => {
+	if (!isConstructor(subject)) throw TypeError('subject is not a constructor')
+}
+
+assertType.isError = (subject: Error): asserts subject is Error => {
+	if (!(subject instanceof Error)) throw TypeError('subject is not an Error')
+}
+assertType.noError = <S>(subject: Exclude<S, Error>): void => {
+	if (subject instanceof Error) throw TypeError('subject is an Error')
+}
+
+assertType.isNever = (_subject: never): asserts _subject is never => { }
+
+/**
+ * creates a custom assertion function with standard TypeError.
+ * Currently this requires explicity type annotation,
+ * thus making it hard to use:
+ * https://github.com/microsoft/TypeScript/issues/41047
+ */
+assertType.custom = <T>(validator: (s: T) => boolean): (subject: unknown) => asserts subject is T => (subject) => {
+		if (!validator(subject as any)) throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
+		return
+	}
+
+assertType.as = <T>(_subject: unknown): asserts _subject is T => { }

package/src/bigint/is_bigint.ts

@@ -0,0 +1,114 @@
+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 { $ResolveOptions } from '../type_plus/$resolve_options.js'
+import type { $SpecialType } from '../type_plus/$special_type.js'
+import type { $Exact } from '../type_plus/branch/$exact.js'
+import type { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
+import type { $Else, $Then } from '../type_plus/branch/$selection.js'
+
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is `bigint` or `bigint` literals.
+ *
+ * @example
+ * ```ts
+ * type R = IsBigint<bigint> // true
+ * type R = IsBigint<1n> // true
+ *
+ * type R = IsBigint<never> // false
+ * type R = IsBigint<unknown> // false
+ * type R = IsBigint<string | boolean> // false
+ *
+ * type R = IsBigint<string | bigint> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is `bigint` or `bigint` literals, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsBigint<bigint, { selection: 'filter' }> // bigint
+ * type R = IsBigint<1n, { selection: 'filter' }> // 1n
+ *
+ * type R = IsBigint<never, { selection: 'filter' }> // never
+ * type R = IsBigint<unknown, { selection: 'filter' }> // never
+ * type R = IsBigint<string | boolean, { selection: 'filter' }> // never
+ *
+ * type R = IsBigint<string | bigint> // bigint
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Validate if `T` is exactly `bigint`.
+ *
+ * @example
+ * ```ts
+ * type R = IsBigint<bigint, { exact: true }> // true
+ * type R = IsBigint<1n, { exact: true }> // false
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = IsBigint<bigint | 1> // boolean
+ * type R = IsBigint<bigint | 1, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsBigint<bigint, $SelectionBranch> // $Then
+ * type R = IsBigint<string, $SelectionBranch> // $Else
+ * ```
+ */
+export type IsBigint<T, $O extends IsBigint.$Options = {}> =
+	$SpecialType<T,
+		$MergeOptions<$O,
+			{
+				$then: $ResolveBranch<T, $O, [$Else]>,
+				$else: IsBigint.$<T, $O>
+			}
+		>
+	>
+
+export namespace IsBigint {
+	export type $Options = $Equality.$Options & $Exact.$Options
+	export type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>
+
+	/**
+	 * 🧰 *type util*
+	 *
+	 * Validate if `T` is `bigint` or `bigint` literals.
+	 *
+	 * This is a type util for building custom types.
+	 * It does not check against special types.
+	 */
+	export type $<T, $O extends $UtilOptions> =
+		$ResolveOptions<[$O['exact'], $Exact.$Default]> extends true
+		? $IsDistributive<$O, { $then: _SD<T, $O>, $else: _SN<T, $O> }>
+		: Assignable.$<T, bigint, $O>
+	export type $UtilOptions = Assignable.$UtilOptions & $Exact.$Options
+
+	export type _SD<T, $O extends $Options> =
+		T extends bigint & infer U
+		? (
+			U extends bigint
+			? $ResolveBranch<T, $O, [$Else]>
+			: $ResolveBranch<T, $O, [$Then]>
+		)
+		: $ResolveBranch<T, $O, [$Else]>
+	export type _SN<T, $O extends $Options> =
+		[T] extends [bigint & infer U] ?
+		U extends bigint ? $ResolveBranch<T, $O, [$Else]>
+		: $ResolveBranch<T, $O, [$Then]>
+		: $ResolveBranch<T, $O, [$Else]>
+}

package/src/bigint/is_bigint_literal.ts

@@ -0,0 +1,100 @@
+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 { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
+import type { $Else, $Then } from '../type_plus/branch/$selection.js'
+
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is bigint literals.
+ *
+ * @example
+ * ```ts
+ * type R = IsBigintLiteral<bigint> // false
+ * type R = IsBigintLiteral<1n> // true
+ *
+ * type R = IsBigintLiteral<never> // false
+ * type R = IsBigintLiteral<unknown> // false
+ * type R = IsBigintLiteral<string | boolean> // false
+ *
+ * type R = IsBigintLiteral<string | number> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is bigint literals, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsBigintLiteral<bigint, { selection: 'filter' }> // never
+ * type R = IsBigintLiteral<1n, { selection: 'filter' }> // 1n
+ *
+ * type R = IsBigintLiteral<never, { selection: 'filter' }> // never
+ * type R = IsBigintLiteral<unknown, { selection: 'filter' }> // never
+ * type R = IsBigintLiteral<string | boolean, { selection: 'filter' }> // never
+ *
+ * type R = IsBigintLiteral<string | number> // number
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = IsBigintLiteral<1n | string> // boolean
+ * type R = IsBigintLiteral<1n | string, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsBigintLiteral<1n, $SelectionBranch> // $Then
+ * type R = IsBigintLiteral<string, $SelectionBranch> // $Else
+ * ```
+ */
+export type IsBigintLiteral<T, $O extends IsBigintLiteral.$Options = {}> = $SpecialType<T,
+	$MergeOptions<$O,
+		{
+			$then: $ResolveBranch<T, $O, [$Else]>,
+			$else: IsBigintLiteral.$<T, $O>
+		}
+	>
+>
+
+export namespace IsBigintLiteral {
+	export type $Options = $Equality.$Options
+	export type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>
+
+	/**
+	 * 🧰 *type util*
+	 *
+	 * Validate if `T` is bigint literals.
+	 *
+	 * This is a type util for building custom types.
+	 * It does not check against special types.
+	 */
+	export type $<T, $O extends $UtilOptions> =
+		$IsDistributive<$O, { $then: _D<T, $O>, $else: _N<T, $O> }>
+
+	export type $UtilOptions = Assignable.$UtilOptions
+
+	export type _D<T, $O extends $UtilOptions> =
+		T extends bigint & infer U
+		? (
+			U extends bigint
+			? $ResolveBranch<T, $O, [$Then]>
+			: $ResolveBranch<T, $O, [$Else]>
+		)
+		: $ResolveBranch<T, $O, [$Else]>
+	export type _N<T, $O extends $UtilOptions> =
+		[T] extends [bigint & infer U] ?
+		U extends bigint ? $ResolveBranch<T, $O, [$Then]>
+		: $ResolveBranch<T, $O, [$Else]>
+		: $ResolveBranch<T, $O, [$Else]>
+}

package/src/bigint/is_not_bigint.ts

@@ -0,0 +1,110 @@
+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 { $ResolveOptions } from '../type_plus/$resolve_options.js'
+import type { $SpecialType } from '../type_plus/$special_type.js'
+import type { $Exact } from '../type_plus/branch/$exact.js'
+import type { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
+import type { $Else, $Then } from '../type_plus/branch/$selection.js'
+
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is not `bigint` nor `bigint` literals.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigint<bigint> // false
+ * type R = IsNotBigint<1n> // false
+ *
+ * type R = IsNotBigint<never> // true
+ * type R = IsNotBigint<unknown> // true
+ * type R = IsNotBigint<string | boolean> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is not `bigint` nor `bigint` literals, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigint<bigint, { selection: 'filter' }> // never
+ * type R = IsNotBigint<1n, { selection: 'filter' }> // never
+ *
+ * type R = IsNotBigint<never, { selection: 'filter' }> // never
+ * type R = IsNotBigint<unknown, { selection: 'filter' }> // unknown
+ * type R = IsNotBigint<string | boolean, { selection: 'filter' }> // string | boolean
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Validate if `T` is not exactly `bigint`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigint<bigint, { exact: true }> // false
+ * type R = IsNotBigint<1n, { exact: true }> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Disable distribution of union types.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigint<bigint | 1> // boolean
+ * type R = IsNotBigint<bigint | 1, { distributive: false }> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigint<string, $SelectionBranch> // $Then
+ * type R = IsNotBigint<bigint, $SelectionBranch> // $Else
+ * ```
+ */
+export type IsNotBigint<T, $O extends IsNotBigint.$Options = {}> = $SpecialType<T,
+	$MergeOptions<$O,
+		{
+			$then: $ResolveBranch<T, $O, [$Then]>,
+			$else: IsNotBigint.$<T, $O>
+		}
+	>
+>
+
+export namespace IsNotBigint {
+	export type $Options = $Equality.$Options & $Exact.$Options
+	export type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>
+
+	/**
+	 * 🧰 *type util*
+	 *
+	 * Validate if `T` is not `bigint` nor `bigint` literals.
+	 *
+	 * This is a type util for building custom types.
+	 * It does not check against special types.
+	 */
+	export type $<T, $O extends $UtilOptions> =
+		$ResolveOptions<[$O['exact'], false]> extends true
+		? $IsDistributive<$O, { $then: _SD<T, $O>, $else: _SN<T, $O> }>
+		: NotAssignable.$<T, bigint, $O>
+	export type $UtilOptions = NotAssignable.$UtilOptions & $Exact.$Options
+
+	export type _SD<T, $O extends $Options> =
+		T extends bigint & infer U
+		? (
+			U extends bigint
+			? $ResolveBranch<T, $O, [$Then]>
+			: $ResolveBranch<T, $O, [$Else]>
+		)
+		: $ResolveBranch<T, $O, [$Then]>
+	export type _SN<T, $O extends $Options> = (
+		[T] extends [bigint & infer U] ?
+		U extends bigint ? $ResolveBranch<T, $O, [$Then]>
+		: $ResolveBranch<T, $O, [$Else]>
+		: $ResolveBranch<T, $O, [$Then]>)
+}

package/src/bigint/is_not_bigint_literal.ts

@@ -0,0 +1,101 @@
+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 { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
+import type { $Else, $Then } from '../type_plus/branch/$selection.js'
+
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is not bigint literals.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigintLiteral<bigint> // true
+ * type R = IsNotBigintLiteral<1n> // false
+ *
+ * type R = IsNotBigintLiteral<never> // true
+ * type R = IsNotBigintLiteral<unknown> // true
+ * type R = IsNotBigintLiteral<string | boolean> // true
+ *
+ * type R = IsNotBigintLiteral<string | 1n> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is not bigint literals, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigintLiteral<bigint, { selection: 'filter' }> // bigint
+ * type R = IsNotBigintLiteral<1n, { selection: 'filter' }> // never
+ *
+ * type R = IsNotBigintLiteral<never, { selection: 'filter' }> // never
+ * type R = IsNotBigintLiteral<unknown, { selection: 'filter' }> // unknown
+ * type R = IsNotBigintLiteral<1n | string, { selection: 'filter' }> // string
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = IsNotBigintLiteral<1n | string> // boolean
+ * type R = IsNotBigintLiteral<1n | string, { distributive: false }> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigintLiteral<1n, $SelectionBranch> // $Else
+ * type R = IsNotBigintLiteral<bigint, $SelectionBranch> // $Then
+ * ```
+ */
+export type IsNotBigintLiteral<T, $O extends IsNotBigintLiteral.$Options = {}> = $SpecialType<T,
+	$MergeOptions<$O,
+		{
+			$then: $ResolveBranch<T, $O, [$Then]>,
+			$else: IsNotBigintLiteral.$<T, $O>
+		}
+	>
+>
+
+export namespace IsNotBigintLiteral {
+	export type $Options = $Equality.$Options
+	export type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>
+
+	/**
+	 * 🧰 *type util*
+	 *
+	 * Validate if `T` is not number literals.
+	 *
+	 * This is a type util for building custom types.
+	 * It does not check against special types.
+	 */
+	export type $<T, $O extends $UtilOptions> =
+		$IsDistributive<$O, {
+			$then: _D<T, $O>,
+			$else: _N<T, $O>
+		}>
+
+	export type $UtilOptions = Assignable.$UtilOptions
+
+	export type _D<T, $O extends $UtilOptions> =
+		T extends bigint & infer U
+		? (
+			U extends bigint
+			? $ResolveBranch<T, $O, [$Else]>
+			: $ResolveBranch<T, $O, [$Then]>
+		)
+		: $ResolveBranch<T, $O, [$Then]>
+	export type _N<T, $O extends $UtilOptions> =
+		[T] extends [bigint & infer U] ?
+		U extends bigint ? $ResolveBranch<T, $O, [$Else]>
+		: $ResolveBranch<T, $O, [$Then]>
+		: $ResolveBranch<T, $O, [$Then]>
+}

package/src/bigint/readme.md

@@ -0,0 +1,109 @@
+# bigint
+
+`bigint` is a type to represent integers that are too large to be represented by a `number`.
+
+## [IsBigint](./is_bigint.ts)
+
+`IsBigint<T, { distributive: true, selection: 'predicate' | 'filter', $then: true, $else: false }>`
+
+🎭 *predicate*
+
+Validate if `T` is `bigint` or `bigint` literals.
+
+```ts
+type R = IsBigint<bigint> // true
+type R = IsBigint<1n> // true
+
+type R = IsBigint<never> // false
+type R = IsBigint<unknown> // false
+type R = IsBigint<string | boolean> // false
+
+type R = IsBigint<string | bigint> // boolean
+```
+
+🔢 *customize*
+
+Filter to ensure `T` is `bigint` or `bigint` literals, otherwise returns `never`.
+
+```ts
+type R = IsBigint<bigint, { selection: 'filter' }> // bigint
+type R = IsBigint<1n, { selection: 'filter' }> // 1n
+
+type R = IsBigint<never, { selection: 'filter' }> // never
+type R = IsBigint<unknown, { selection: 'filter' }> // never
+type R = IsBigint<string | boolean, { selection: 'filter' }> // never
+
+type R = IsBigint<string | bigint> // bigint
+```
+
+🔢 *customize*:
+
+Disable distribution of union types.
+
+```ts
+type R = IsBigint<bigint | 1> // boolean
+type R = IsBigint<bigint | 1, { distributive: false }> // false
+```
+
+🔢 *customize*
+
+Use unique branch identifiers to allow precise processing of the result.
+
+```ts
+type R = IsBigint<bigint, $SelectionBranch> // $Then
+type R = IsBigint<string, $SelectionBranch> // $Else
+```
+
+## [IsNotBigint](./is_not_bigint.ts)
+
+`IsNotBigint<T, { distributive: true, selection: 'predicate' | 'filter', $then: false, $else: true }>`
+
+🎭 *predicate*
+
+Validate if `T` is not `bigint` nor `bigint` literals.
+
+```ts
+type R = IsNotBigint<bigint> // false
+type R = IsNotBigint<1n> // false
+
+type R = IsNotBigint<never> // true
+type R = IsNotBigint<unknown> // true
+type R = IsNotBigint<string | boolean> // true
+```
+
+🔢 *customize*
+
+Filter to ensure `T` is not `bigint` nor `bigint` literals, otherwise returns `never`.
+
+```ts
+type R = IsNotBigint<bigint, { selection: 'filter' }> // never
+type R = IsNotBigint<1n, { selection: 'filter' }> // never
+
+type R = IsNotBigint<never, { selection: 'filter' }> // never
+type R = IsNotBigint<unknown, { selection: 'filter' }> // unknown
+type R = IsNotBigint<string | boolean, { selection: 'filter' }> // string | boolean
+```
+
+🔢 *customize*
+
+Disable distribution of union types.
+
+```ts
+type R = IsNotBigint<bigint | 1> // boolean
+type R = IsNotBigint<bigint | 1, { distributive: false }> // true
+```
+
+🔢 *customize*
+
+Use unique branch identifiers to allow precise processing of the result.
+
+```ts
+type R = IsNotBigint<string, $SelectionBranch> // $Then
+type R = IsNotBigint<bigint, $SelectionBranch> // $Else
+```
+
+## References
+
+- [mdn web docs: BigInt][mdn]
+
+[mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt