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

package/src/unknown/readme.md

@@ -0,0 +1,108 @@
+# unknown
+
+`unknown` is one of the top types in TypeScript.
+It is a "safer" variant of `any` that you cannot use the value until there are some type guards or type assertions to the value.
+
+`unknown | T => unknown` except `unknown | any => any.
+
+`unknown & T => T`
+
+## [IsUnknown](./is_unknown.ts)
+
+`IsUnknown<T, $Options = { selection: 'predicate' | 'filter', $then: true, $else: false }>`
+
+🎭 *predicate*
+
+Validate if `T` is exactly `unknown`.
+
+```ts
+type R = IsUnknown<unknown> // true
+
+type R = IsUnknown<number> // false
+type R = IsUnknown<never> // false
+```
+
+🔢 *customize*
+
+Filter to ensure `T` is exactly `unknown`.
+
+```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.
+
+```ts
+type R = IsUnknown<unknown, $SelectionBranch> // $Then
+type R = IsUnknown<string, $SelectionBranch> // $Else
+```
+
+### [IsNotUnknown](./is_not_unknown.ts)
+
+`IsNotUnknown<T, $Options = { selection: 'predicate' | 'filter', $then: true, $else: false }>`
+
+🎭 *predicate*
+
+Validate if `T` is not exactly `unknown`.
+
+```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`.
+
+```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.
+
+```ts
+type R = IsNotUnknown<unknown, $SelectionBranch> // $Else
+type R = IsNotUnknown<string, $SelectionBranch> // $Then
+```
+
+### [NotUnknownOr](./not_unknown_or.ts)
+
+`NotUnknownOr<T, Else>`
+
+🌪️ *filter*
+
+Returns `T` if `T` is not `unknown`, otherwise `$Unknown`.
+
+```ts
+type R = NotUnknownOr<number> // number
+type R = NotUnknownOr<unknown> // $Unknown
+
+// customize
+type R = NotUnknownOr<unknown, number> // number
+```
+
+🔢 *customize*
+
+Replace `unknown` branch with `Replace`.
+
+```ts
+type R = NotUnknownOr<unknown, number> // number
+```
+
+## References
+
+- [Handbook]
+
+[handbook]: https://www.typescriptlang.org/docs/handbook/2/functions.html#unknown

package/src/unknown/unknown.ts

@@ -0,0 +1,58 @@
+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 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
+	 * }
+	 * ```
+	 */
+	export 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
+	 * ```
+	 */
+	export type $Branch = {
+		$unknown: $Unknown
+	}
+}

package/src/utils/index.ts

@@ -0,0 +1,61 @@
+export * from './as.js'
+export * from './inspect.js'
+export type { Widen } from './Widen.js'
+
+/**
+ * `A` | `B` | `A & B`.
+ * Supports up to 4 types, and it is composable.
+ * This is useful when you want to compose multiple options together,
+ * while preserving their required field and structure.
+ * If the types overlaps each other, you may run into some corner cases.
+ * But in general usage it should work as expected.
+ * @example
+ * type A = { src: string, minify?: boolean }
+ * type B = { logLevel: number }
+ * function config(options: EitherAnd<A, B>) { }
+ *
+ * config({ logLevel: 1 })
+ * config({ src: 'src' })
+ * config({ src: 'src', minify: false })
+ * config({ minify: false })  // INVALID
+ */
+export type EitherOrBoth<A, B, C = void, D = void> = C extends void
+	? A | B | (A & B)
+	: D extends void
+	? A | B | C | (A & B) | (A & C) | (B & C) | (A & B & C)
+	:
+			| A
+			| B
+			| C
+			| D
+			| (A & B)
+			| (A & C)
+			| (A & D)
+			| (B & C)
+			| (B & D)
+			| (C & D)
+			| (A & B & C)
+			| (A & B & D)
+			| (A & C & D)
+			| (B & C & D)
+			| (A & B & C & D)
+
+/**
+ * `A` | `B` | `A & B`.
+ * Supports up to 4 types, and it is composable.
+ * This is useful when you want to compose multiple options together,
+ * while preserving their required field and structure.
+ * If the types overlaps each other, you may run into some corner cases.
+ * But in general usage it should work as expected.
+ * @deprecated renamed to `EitherOrBoth`
+ * @example
+ * type A = { src: string, minify?: boolean }
+ * type B = { logLevel: number }
+ * function config(options: EitherAnd<A, B>) { }
+ *
+ * config({ logLevel: 1 })
+ * config({ src: 'src' })
+ * config({ src: 'src', minify: false })
+ * config({ minify: false })  // INVALID
+ */
+export type EitherAnd<A, B, C = void, D = void> = EitherOrBoth<A, B, C, D>

package/src/utils/options.ts

@@ -0,0 +1,15 @@
+export namespace TypePlusOptions {
+	/**
+	 * 🦴 *utilities*
+	 * ㊙️ *internal*
+	 *
+	 * Merge the input Options `I` with the default Options `D`.
+	 */
+	export type Merge<I, D> = {
+		[k in keyof D]: k extends keyof I ? I[k] : D[k]
+	}
+
+	export interface NotArray {
+		$notArray?: unknown
+	}
+}

package/src/void/is_not_void.ts

@@ -0,0 +1,90 @@
+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'
+import type { IsUndefined } from '../undefined/is_undefined.js'
+
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is not `void`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotVoid<void> // false
+ *
+ * type R = IsNotVoid<never> // true
+ * type R = IsNotVoid<unknown> // true
+ * type R = IsNotVoid<string | boolean> // true
+ *
+ * type R = IsNotVoid<string | void> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is not `void`, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotVoid<void, { selection: 'filter' }> // never
+ *
+ * type R = IsNotVoid<never, { selection: 'filter' }> // never
+ * type R = IsNotVoid<unknown, { selection: 'filter' }> // unknown
+ * type R = IsNotVoid<string | void, { selection: 'filter' }> // string
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotVoid<void | string> // boolean
+ * type R = IsNotVoid<void | string, { distributive: false }> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotVoid<void, $SelectionBranch> // $Else
+ * type R = IsNotVoid<string, $SelectionBranch> // $Then
+ * ```
+ */
+export type IsNotVoid<
+	T,
+	$O extends IsNotVoid.$Options = {}
+> =
+	$SpecialType<T,
+		$MergeOptions<$O,
+			{
+				$then: $ResolveBranch<T, $O, [$Then]>,
+				$else: IsNotVoid.$<T, $O>
+			}
+		>
+	>
+
+export namespace IsNotVoid {
+	export type $Options = $Equality.$Options
+	export 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.
+	 */
+	export type $<T, $O extends $UtilOptions> =
+		IsUndefined.$<T, {
+			$then: $ResolveBranch<T, $O, [$Then]>,
+			$else: NotAssignable.$<T, void, $O>
+		}>
+
+	export type $UtilOptions = NotAssignable.$UtilOptions
+}

package/src/void/is_void.ts

@@ -0,0 +1,91 @@
+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'
+import type { IsUndefined } from '../undefined/is_undefined.js'
+
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is `void`.
+ *
+ * @example
+ * ```ts
+ * type R = IsVoid<void> // true
+ *
+ * type R = IsVoid<never> // false
+ * type R = IsVoid<unknown> // false
+ * type R = IsVoid<string | boolean> // false
+ *
+ * type R = IsVoid<string | void> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is `void`, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsVoid<void, { selection: 'filter' }> // void
+ *
+ * type R = IsVoid<never, { selection: 'filter' }> // never
+ * type R = IsVoid<unknown, { selection: 'filter' }> // never
+ * type R = IsVoid<string | boolean, { selection: 'filter' }> // never
+ *
+ * type R = IsVoid<string | void> // void
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = IsVoid<void | 1> // boolean
+ * type R = IsVoid<void | 1, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsVoid<void, $SelectionBranch> // $Then
+ * type R = IsVoid<string, $SelectionBranch> // $Else
+ * ```
+ */
+export type IsVoid<
+	T,
+	$O extends IsVoid.$Options = {}
+> =
+	$SpecialType<T,
+		$MergeOptions<$O,
+			{
+				$then: $ResolveBranch<T, $O, [$Else]>,
+				$else: IsVoid.$<T, $O>
+			}
+		>
+	>
+
+export namespace IsVoid {
+	export type $Options = $Equality.$Options
+	export 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.
+	 */
+	export type $<T, $O extends $UtilOptions> =
+		IsUndefined.$<T, {
+			$then: $ResolveBranch<T, $O, [$Else]>,
+			$else: Assignable.$<T, void, $O>
+		}>
+
+	export type $UtilOptions = Assignable.$UtilOptions
+}

package/src/void/readme.md

@@ -0,0 +1,108 @@
+# void
+
+`void` is a type that represents the absence of type information.
+It is typically used as the return type of a function that does not explicitly return a value.
+
+## [IsVoid](./is_void.ts)
+
+`IsVoid<T, { distributive: true, selection: 'predicate' | 'filter', $then: true, $else: false }>`
+
+🎭 *predicate*
+
+Validate if `T` is `void`.
+
+```ts
+type R = IsVoid<void> // true
+
+type R = IsVoid<never> // false
+type R = IsVoid<unknown> // false
+type R = IsVoid<string | boolean> // false
+
+type R = IsVoid<string | void> // boolean
+```
+
+🔢 *customize*
+
+Filter to ensure `T` is `void`, otherwise returns `never`.
+
+```ts
+type R = IsVoid<void, { selection: 'filter' }> // void
+
+type R = IsVoid<never, { selection: 'filter' }> // never
+type R = IsVoid<unknown, { selection: 'filter' }> // never
+type R = IsVoid<string | boolean, { selection: 'filter' }> // never
+
+type R = IsVoid<string | void> // void
+```
+
+🔢 *customize*:
+
+Disable distribution of union types.
+
+```ts
+type R = IsVoid<void | 1> // boolean
+type R = IsVoid<void | 1, { distributive: false }> // false
+```
+
+🔢 *customize*
+
+Use unique branch identifiers to allow precise processing of the result.
+
+```ts
+type R = IsVoid<void, $SelectionBranch> // $Then
+type R = IsVoid<string, $SelectionBranch> // $Else
+```
+
+## [IsNotVoid](./is_not_void.ts)
+
+`IsNotVoid<T, { distributive: true, selection: 'predicate' | 'filter', $then: true, $else: false }>`
+
+🎭 *predicate*
+
+Validate if `T` is not `void`.
+
+```ts
+type R = IsNotVoid<void> // false
+
+type R = IsNotVoid<never> // true
+type R = IsNotVoid<unknown> // true
+type R = IsNotVoid<string | boolean> // true
+
+type R = IsNotVoid<string | void> // boolean
+```
+
+🔢 *customize*
+
+Filter to ensure `T` is not `void`, otherwise returns `never`.
+
+```ts
+type R = IsNotVoid<void, { selection: 'filter' }> // never
+
+type R = IsNotVoid<never, { selection: 'filter' }> // never
+type R = IsNotVoid<unknown, { selection: 'filter' }> // unknown
+type R = IsNotVoid<string | void, { selection: 'filter' }> // string
+```
+
+🔢 *customize*:
+
+Disable distribution of union types.
+
+```ts
+type R = IsNotVoid<void | string> // boolean
+type R = IsNotVoid<void | string, { distributive: false }> // true
+```
+
+🔢 *customize*
+
+Use unique branch identifiers to allow precise processing of the result.
+
+```ts
+type R = IsNotVoid<void, $SelectionBranch> // $Else
+type R = IsNotVoid<string, $SelectionBranch> // $Then
+```
+
+## References
+
+- [Handbook]
+
+[handbook]: https://www.typescriptlang.org/docs/handbook/2/functions.html#void

package/esm/any/any_type.d.ts

@@ -1,63 +0,0 @@
-/**
- * 🌪️ *filter*
- *
- * Filter `T` to ensure it is exactly `any`.
- *
- * @example
- * ```ts
- * type R = AnyType<any> // any
- *
- * type R = AnyType<never> // never
- * type R = AnyType<unknown> // never
- * type R = AnyType<string | boolean> // never
- * ```
- */
-export type AnyType<T, Then = T, Else = never> = 0 extends 1 & T ? Then : Else;
-/**
- * 🎭 *validate*
- *
- * Validate if `T` is exactly `any`.
- *
- * @example
- * ```ts
- * type R = IsAny<any> // true
- *
- * type R = IsAny<never> // false
- * type R = IsAny<unknown> // false
- * type R = IsAny<string | boolean> // false
- * ```
- */
-export type IsAny<T, Then = true, Else = false> = AnyType<T, Then, Else>;
-/**
- * 🌪️ *filter*
- *
- * Filter `T` to ensure it is not exactly `any`.
- *
- * @example
- * ```ts
- * type R = NotAnyType<any> // never
- *
- * type R = NotAnyType<never> // never
- * type R = NotAnyType<unknown> // unknown
- * type R = NotAnyType<string | boolean> // string | boolean
- * ```
- */
-export type NotAnyType<T, Then = T, Else = never> = AnyType<T, Else, Then>;
-/**
- * 🎭 *validate*
- *
- * Validate if `T` is not exactly `any`.
- *
- * @example
- * ```ts
- * import type { IsNotAny } from 'type-plus'
- *
- * type R = IsNotAny<any> // false
- *
- * type R = IsNotAny<never> // true
- * type R = IsNotAny<unknown> // true
- * type R = IsNotAny<string | boolean> // true
- * ```
- */
-export type IsNotAny<T, Then = true, Else = false> = AnyType<T, Else, Then>;
-//# sourceMappingURL=any_type.d.ts.map

package/esm/any/any_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"any_type.d.ts","sourceRoot":"","sources":["../../ts/any/any_type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAA;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAExE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE1E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/any/any_type.js

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

package/esm/any/any_type.js.map

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

package/esm/array/array_type.d.ts

@@ -1,66 +0,0 @@
-import type { IsNever } from '../never/never_type.js';
-import type { StrictNumberType } from '../number/strict_number_type.js';
-/**
- * 🌪️ *filter*
- *
- * Filter `T` to ensure it is an array, excluding tuple.
- *
- * @example
- * ```ts
- * type R = ArrayType<number[]> // number[]
- *
- * type R = ArrayType<[1]> // never
- * type R = ArrayType<number[] | 1> // never
- * type R = ArrayType<number[] & { a: 1 }> // never
- * ```
- */
-export type ArrayType<T, Then = T, Else = never> = IsNever<T, Else, [
-    never[]
-] extends [T] ? ([T] extends [readonly any[]] ? StrictNumberType<T['length'], Then, Else> : Else) : Else>;
-/**
- * 🎭 *validate*
- *
- * Validate that `T` is an array, excluding tuple.
- *
- * @example
- * ```ts
- * type R = IsArray<number[]> // true
- *
- * type R = IsArray<number> // false
- * type R = IsArray<[1]> // false
- * ```
- */
-export type IsArray<T, Then = true, Else = false> = ArrayType<T, Then, Else>;
-/**
- * 🌪️ *filter*
- *
- * Filter `T` to ensure it is not an array, excluding tuple.
- *
- * i.e. *tuple* will pass through this filter.
- *
- * @example
- * ```ts
- * type R = NotArrayType<number[]> // never
- *
- * type R = NotArrayType<number> // number
- * type R = NotArrayType<[1]> // [1]
- * ```
- */
-export type NotArrayType<T, Then = T, Else = never> = ArrayType<T, Else, Then>;
-/**
- * 🎭 *validate*
- *
- * Validate that `T` is not an array, excluding tuple.
- *
- * i.e. *tuple* will pass through this filter.
- *
- * @example
- * ```ts
- * type R = IsNotArray<number[]> // false
- *
- * type R = IsNotArray<number> // true
- * type R = IsNotArray<[1]> // true
- * ```
- */
-export type IsNotArray<T, Then = true, Else = false> = ArrayType<T, Else, Then>;
-//# sourceMappingURL=array_type.d.ts.map

package/esm/array/array_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array_type.d.ts","sourceRoot":"","sources":["../../ts/array/array_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAEvE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CACzD,CAAC,EACD,IAAI,EACJ;IAAC,KAAK,EAAE;CAAC,SAAS,CAAC,CAAC,CAAC,GACnB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,GAAG,EAAE,CAAC,GAC5B,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,GACzC,IAAI,CAAC,GACN,IAAI,CACN,CAAA;AAED;;;;;;;;;;;;GAYG;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;;;;;;;;;;;;;;GAcG;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;;;;;;;;;;;;;;GAcG;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/array/array_type.js

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

package/esm/array/array_type.js.map

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