diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 00000000..8e103359
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [angular-package] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: sciborrudnicki # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
diff --git a/.gitignore b/.gitignore
index 46b625e7..7e4e96c8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -126,3 +126,8 @@ build
 dist
 graphics
 fonts
+*.ignore*
+
+# demos
+demo
+
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 00000000..bcb84eac
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,132 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## [5.0.0] - 2022-01-30
+
+### [5.0.0] Added
+
+- Added `Undefined` generic type.
+- Added guard function `guardStringLengthBetween()`. [53e02d8]
+- Added check function `isStringLengthBetween()`. [5d044f9]
+- Added generic type `GenericObject`. [fd14947]
+- Added `guardStringIncludes()` and `guardStringIncludesSome()` functions with tests. [691f07e]
+- Added `guardObjectKeysIn()` function to guard the value to be an `object` with specified keys in it(or its prototype chain). [21e523b]
+- Added `are` prefixed functions to check the values of a rest parameter. `areBigInt()` `areBoolean()` `areDate()` `areDefined()` `areFalse()` `areNull()` `areNumber()` `areRegExp()` `areSymbol()` `areTrue()` `areUndefined()`. [823dac3]
+- Added a generic type `MinMax` that takes generic type variable `Min` and `Max` that represents the range between minimum and maximum. [e503d38]
+- Added new guard functions `guardDate()`, `guardFalse()`, `guardNumberBetween()`, `guardObjectKeyIn()`, `guardObjectSomeKeys()`, `guardRegExp()`, `guardStringLength()`, `guardTrue()`. [c374612]
+- Added `isObjectKeysIn()`, `isObjectSomeKeys()`, `isStringIncludes()` and `isStringIncludesSome()` and to the `is` object and to the `Is` interface.  [55635fa] [1e48fb1] [a4cb61d] [f809f32] [5c85a03] [d440e38] [0efe8ae]
+- Added `CallbackPayload` and `ForEachCallback` types. [98a2722]
+- Added the `type` object consists of `are`, `is` and `guard` objects. [dfb3df9]
+- Added an object to handle executing the tests. [8dd8099] [230063b]
+- Added `recognizeValue()` to recognize type of any value. [d2f756e]
+
+[53e02d8]: https://github.com/angular-package/type/commit/53e02d8fdf33ef9c2a66615be19c22eb3a606b12
+[5d044f9]: https://github.com/angular-package/type/commit/5d044f9a8a5dce0c3e79f6858b0e29a81cf3f3d5
+[fd14947]: https://github.com/angular-package/type/commit/fd1494735a7ddf6653919448b67984cbb341bbdc
+[691f07e]: https://github.com/angular-package/type/commit/691f07e2cf31eb3a52923715ef091f86a181a15f
+[21e523b]: https://github.com/angular-package/type/commit/21e523b3a46e3e8243276e5008de72ea9b3c3756
+[0efe8ae]: https://github.com/angular-package/type/commit/0efe8aed83d03313921176206636bc8b0730d188
+[d440e38]: https://github.com/angular-package/type/commit/d440e388f6f853c01ef9aab620c206f2233bd3cf
+[5c85a03]: https://github.com/angular-package/type/commit/5c85a03a7fd34dd64a650597f48cea9968940f68
+[f809f32]: https://github.com/angular-package/type/commit/f809f32cddd2c53568d60f0af6e57b941d50fa87
+[a4cb61d]: https://github.com/angular-package/type/commit/a4cb61d5b8bfd7f1ac548842d355a045266f6e7b
+[1e48fb1]: https://github.com/angular-package/type/commit/1e48fb1448b908f09cc2628063eff457d920a903
+[823dac3]: https://github.com/angular-package/type/commit/823dac3b62288c1016e8244fc741939bdc140d89
+[e503d38]: https://github.com/angular-package/type/commit/e503d3885d560274e1f30e763e04c526a8548317
+[c374612]: https://github.com/angular-package/type/commit/c374612e96d14c6d23449e03535283e5e1614765
+[55635fa]: https://github.com/angular-package/type/commit/55635fad55a8f0e14486246215cf7f22b9f1ab26
+[98a2722]: https://github.com/angular-package/type/commit/98a2722ea64ccb476942b606239dd001457d7e03
+[230063b]: https://github.com/angular-package/type/commit/230063ba135022fdcbbb65fc3569f248f836adbf
+[8dd8099]: https://github.com/angular-package/type/commit/8dd80991ba9e5950970880d8aa449c1c7a143699
+[dfb3df9]: https://github.com/angular-package/type/commit/dfb3df9f82116cd2737031b255f0aad62e4c1fa8
+[d2f756e]: https://github.com/angular-package/type/commit/d2f756e1498b531836aaac08a9c01b512cdaba2c
+
+### [5.0.0] Changed
+
+- Updated the way of checking values in some of the `is` and `isNot` prefixed functions.
+- Updated `isPrimitive()` and `isType()` function does not use switch on the `type` argument.
+- Updated `guard`, `is`, `isNot` prefixed functions to use updated generic type `ResultCallback` with `payload` parameter of generic type variable `Payload`.
+- Updated `isStringLength()` function to check the specific `length`. [061ab52]
+- Updated `guardStringLength()` function to check the specific `length`. [0e48591]
+- Updated `is {}` object by adding `stringLengthBetween` method. [083ffd0]
+- Updated `guardIs` object by adding `objectKeysIn`, `stringIncludes`, `stringLengthBetween` and `stringIncludesSome` methods. [8679b4c] [1d44d2e]
+- Updated `GuardIs` interface by adding `stringLengthBetween`. [7387e23]
+- Updated `areString()` function that works by using the returned methods. [68c9365]
+- Freeze the `guard`, `guardIs`, `isNot` and `is` object. [00e8841] [09fb70f] [c4e6f8f] [0efe8ae]
+- Updated `isObject()` function by adding the ability to check any kind of object, not only the `Object`. [de6aa12]
+- Updated `NumberBetween` interface by adding `MinMax` interface and a generic type variable `Type`. [1263a2e]
+- Updated `StringOfLength` interface by adding `MinMax` interface and a generic type variable `Type`. [24621f7]
+- Updated `isInstance()` function can now check any kind of instance. [7d288c2]
+- Updated `Is` interface by adding `stringLengthBetween`. [26d7a9d] [8ddb720]
+- Updated `Is` interface and `isNot` by changing the function types to the `typeof` operator. [8ddb720] [8ddb720]
+- Updated the type of callback function `ResultCallback` to provide the type of value and the shape of `payload`. [8ddb720] [34a1b1f]
+- Updated functions by adding a generic type variable `Payload` constrained by the `object` type that is by default equal to the `object`. [5c9486f]
+- Updated functions by adding a `payload` parameter of generic type ~~`CallbackPayload`~~ that takes generic type variable `Payload` to assign to callback function `payload` parameter. [6d190f5]
+- Updated functions by removing `typeOf()` function if it's not necessary to use it. [8ddb720]
+- Updated the `Defined` to not use of `Never` type cause of some compile issues. [e09a84f]
+- Updated the `guard` object by removing `is` property. [aa80250]
+- Updated the `isParam()` function by removing the `Func` generic type in favor of `Function`. [42065c9]
+- Updated `isObjectKey()`, `isObjectKeyIn` to check only one key instead of multiple keys. [b7092a9]
+- Updated `isObjectKeys()` works differently, now it searches for every key. The previous functionality provides `isObjectSomeKeys()`. [b7092a9]
+
+[0e48591]: https://github.com/angular-package/type/commit/0e485914cc410509efed0bcfa40d29c456fc9b32
+[061ab52]: https://github.com/angular-package/type/commit/061ab521e29b046549f169d5c7ebdd5f8f9f24b6
+[26d7a9d]: https://github.com/angular-package/type/commit/26d7a9d2dc5fd84e5715ccea679bf2412f57c45a
+[1d44d2e]: https://github.com/angular-package/type/commit/1d44d2eb3f69ca372486037bad06aa2feb59419f
+[083ffd0]: https://github.com/angular-package/type/commit/083ffd06832a2381dac4755f0b206eb81d8cc25a
+[8679b4c]: https://github.com/angular-package/type/commit/8679b4c5845880a3be41d6d72dd115a7f4d99be2
+[7387e23]: https://github.com/angular-package/type/commit/7387e2342b7c02ccf64f8cb980cd8b801e333ca9
+[68c9365]: https://github.com/angular-package/type/commit/68c93656d4b3cd1c5158bc6021059929e54860ab
+[0efe8ae]: https://github.com/angular-package/type/commit/0efe8aed83d03313921176206636bc8b0730d188
+[c4e6f8f]: https://github.com/angular-package/type/commit/c4e6f8f033364b24fd864b77ab62c7de70d7c265
+[09fb70f]: https://github.com/angular-package/type/commit/09fb70f87634923dce1fd979da30a8041a7f9922
+[00e8841]: https://github.com/angular-package/type/commit/00e8841cc63430ee6423232ee804196fee9cbfd5
+[de6aa12]: https://github.com/angular-package/type/commit/de6aa127ec3f0821487448d784d390edc35fb289
+[1263a2e]: https://github.com/angular-package/type/commit/1263a2e92f6722dd9d025f5c5eef0e1ba652fe66
+[24621f7]: https://github.com/angular-package/type/commit/24621f7b421392226e939161989b28ae0898524f
+[7d288c2]: https://github.com/angular-package/type/commit/7d288c2290055a164259f6e5ea336bec8938bf66
+[34a1b1f]: https://github.com/angular-package/type/commit/34a1b1fc0fac8b9044d3c4da96d9dc642f388507
+[5c9486f]: https://github.com/angular-package/type/commit/5c9486f859a4e61476c220f228bf1cb34511e319
+[6d190f5]: https://github.com/angular-package/type/commit/6d190f5ef1d425b272ca65954e5a9780f561d3c6
+[e09a84f]: https://github.com/angular-package/type/commit/e09a84fc1ea2109c4c480743e3b749325a1d9c5f
+[aa80250]: https://github.com/angular-package/type/commit/aa80250dec231e10dc11d14c7b86e88c2297e82b
+[42065c9]: https://github.com/angular-package/type/commit/42065c9f7aa938e2d514ff9bfc9b197463a9bbda
+[b7092a9]: https://github.com/angular-package/type/commit/b7092a9766c5706ba2c7ba5670a96553f1ad4bd0
+
+### [5.0.0] Removed
+
+- Removed `guard` prefixed function types. [a8e8566]
+- Removed `Func` type in favor of build-in `Function` type. [8ddb720] [5148f05]
+- Removed `Key` type in favor of build-in `PropertyKey` type. [562ec13]
+- Removed `CycleHook` type. [4d53a55]
+
+[a8e8566]: https://github.com/angular-package/type/commit/a8e856663f8c57c3c89271c1c1948ecdc96b01d1
+[8ddb720]: https://github.com/angular-package/type/commit/8ddb720a071dc97ccfdda8757f911aac1a6ec9bd
+[5148f05]: https://github.com/angular-package/type/commit/5148f059722ee8979d8cf1945f80d8e65290bb0d
+[562ec13]: https://github.com/angular-package/type/commit/562ec1396f61bb8b1c7363097a5e8b9a2e4392bc
+[4d53a55]: https://github.com/angular-package/type/commit/4d53a55a6b26d8a20678ae3dc39544e24cd3d9fa
+
+## [4.2.0] - 2021-06-25
+  
+### Added
+
+* [`a6b567f`](https://github.com/angular-package/type/commit/a6b567f32a00726d2b7ecf38ce7a57a42366aaf6)  
+  New `NumberBetween` and `StringOfLength` type.
+
+* [`21f3f48`](https://github.com/angular-package/type/commit/21f3f48029d79e1dfd4507d3a684ec1e81e44713)  
+  New functions `isDate()`, `isFalse()`, `isNumberBetween()`, `isRegExp()`, `isStringLength()`, `isTrue()` with tests and types.
+
+* [`7d4cda7`](https://github.com/angular-package/type/commit/7d4cda7d3c91fca89a35baed6c1db9cd35070f4e)  
+  This `CHANGELOG.md`.
+
+### Changed
+
+* [`e70b034`](https://github.com/angular-package/type/commit/e70b034934b81b3af6ab1976153cbbad8c148f78)  
+  All types description in the `README.md`.
+
+* [`61e9376`](https://github.com/angular-package/type/commit/61e93766fab7d72cafa70da712f296c6ca6e9304)  
+  Add possibility to use `is` prefixed functions directly from the `guard` eg. `guard.array()`.
diff --git a/README.md b/README.md
index 4ddb0b09..01f2026a 100644
--- a/README.md
+++ b/README.md
@@ -1,24 +1,176 @@
-# Packages
+# angular-package
 
-Useful packages based on the [angular.io](https://angular.io/).
+<img align="left" width="100" height="100" src="https://avatars.githubusercontent.com/u/31412194?s=400&u=c9929aa36826318ccac8f7b84516e1ce3af7e21c&v=4" />
 
-| Package          | Description                                  | Status                                         | Readme                                                 |
-| :--------------- | :------------------------------------------- | :--------------------------------------------: | :----------------------------------------------------- |
-| change-detection | Improve application performance.             | *In Progress*                                  | [Readme][cd-readme-github]                             |
-| prism            | `Prism` highlighter module.                  | *In Progress*                                  | [Readme][prism-readme-github]                          |
-| property         | Features to handle object properties.        | *In Progress*                                  | [Readme][property-readme-github]                       |
-| ui               | User interface.                              | *In Progress*                                  | [Github][ui-readme-github]                             |
-| type             | Common types, type guards and type checkers. | [![npm version][type-npm-svg]][type-npm-badge] | [Github][type-readme-github] \| [npm][type-readme-npm] |
+The angular-package supports the development process of [angular][angulario]-based applications in varied ways through the thoughtful, reusable, easy-to-use small pieces of code called packages.
+
+[**docs.angular-package.dev**](https://docs.angular-package.dev)
+
+<br>
+
+## Packages
+
+| Package                                      | Description                                                       | Status |
+| :------------------------------------------- | :---------------------------------------------------------------- | -----: |
+| [callback][callback-github-readme]           | Manages the callback [`function`][js-function].                   | [![npm version][callback-npm-badge-png]][callback-npm-badge] |
+| [change-detection][cd-github-readme]         | Improves application performance.                                 | [![npm version][cd-npm-badge-png]][cd-npm-badge] |
+| [component-loader][cl-github-readme]         | Handles dynamic loading components.                               | [![npm version][cl-npm-badge-png]][cl-npm-badge] |
+| [core][core-github-readme]                   | Core features.                                                    | [![npm version][core-npm-badge-png]][core-npm-badge] |
+| [error][error-github-readme]                 | Manages an [`Error`][js-error].                                   | [![npm version][error-npm-badge-png]][error-npm-badge] |
+| [name][name-github-readme]                   | The name with prefix and suffix.                                  | [![npm version][name-npm-badge-png]][name-npm-badge] |
+| [preferences][preferences-github-readme]     | Preferences, settings, options, configuration and setup in steps. | [![npm version][preferences-npm-badge-png]][preferences-npm-badge] |
+| [prism][prism-github-readme]                 | [`Prism`][prism-js] highlighter module.                           | [![npm version][prism-npm-badge-png]][prism-npm-badge] |
+| [property][property-github-readme]           | Handles object properties.                                        | [![npm version][property-npm-badge-png]][property-npm-badge] |
+| [range][range-github-readme]                 | The range between a minimum and maximum.                          | [![npm version][range-npm-badge-png]][range-npm-badge] |
+| [reactive][reactive-github-readme]           | Automatize the process of creating some rxjs features.            | [![npm version][reactive-npm-badge-png]][reactive-npm-badge] |
+| [storage][storage-github-readme]             | The storage of data under allowed names.                          | [![npm version][storage-npm-badge-png]][storage-npm-badge] |
+| [tag][tag-github-readme]                     | Any tag with optional attributes.                                 | [![npm version][tag-npm-badge-png]][tag-npm-badge] |
+| [testing][testing-github-readme]             | Support for testing other packages.                               | [![npm version][testing-npm-badge-png]][testing-npm-badge] |
+| [text][text-github-readme]                   | Text on the template with replaceable tags.                       | [![npm version][text-npm-badge-png]][text-npm-badge] |
+| **[type][type-github-readme]**               | **Common types, type guards, and type checkers.**                 | [![npm version][type-npm-badge-png]][type-npm-badge] |
+| [ui][ui-github-readme]                       | User interface.                                                   | *In Progress* |
+| [wrapper][wrapper-github-readme]             | Wrap the text with the opening and closing chars.                 | [![npm version][wrapper-npm-badge-png]][wrapper-npm-badge] |
+
+Click on the package name to visit its [GitHub](https://github.com/) page.
+
+<br>
 
 ## angular-package/type
 
 Common types, type guards and type checkers.
 
-[![npm version][type-npm-svg]][type-npm-badge]
-[![GitHub issues](https://img.shields.io/github/issues/angular-package/type)][issues]
-[![GitHub forks](https://img.shields.io/github/forks/angular-package/type)][forks]
-[![GitHub stars](https://img.shields.io/github/stars/angular-package/type)][stars]
-[![GitHub license](https://img.shields.io/github/license/angular-package/type)][license]
+[![Gitter][gitter-badge]][gitter-chat]
+[![Discord][discord-badge]][discord-channel]
+[![Twitter][twitter-badge]][twitter-follow]
+<!-- npm badge -->
+[![npm version][type-npm-badge-svg]][type-npm-badge]
+<!-- GitHub badges -->
+[![GitHub issues][type-badge-issues]][type-issues]
+[![GitHub forks][type-badge-forks]][type-forks]
+[![GitHub stars][type-badge-stars]][type-stars]
+[![GitHub license][type-badge-license]][type-license]
+<!-- Sponsors badges -->
+[![GitHub sponsors][github-badge-sponsor]][github-sponsor-link]
+[![Support me on Patreon][patreon-badge]][patreon-link]
+
+<br>
+
+## Documentation
+
+For the detailed documentation go to [**https://type.angular-package.dev/**](https://type.angular-package.dev/)
+
+## Table of contents
+
+* [Basic concepts](#basic-concepts)
+* [Skeleton](#skeleton)
+* [Installation](#installation)
+* [Api](#api)
+* [Changelog](#changelog)
+* [Git](#git)
+  * [Commit](#commit)
+  * [Versioning](#versioning)
+* [License](#license)
+
+<br>
+
+## Basic concepts
+
+Checks
+> It's to check the provided value to be **the same** as **expected**.
+
+Type guard (constrain)
+> Constrains the parameter type to **not let** input **unexpected** value in the **code editor**.
+
+Guards
+> It's a **combination** of both above, **constrains** the type of the parameter in the **code editor**, and checks its provided argument.
+
+Defines
+> Returns defined value from a method of an object.  
+> Defines new value in an object and returns a defined value.  
+
+Gets
+> Returns a value from an object.
+
+Sets
+> Adds or updates an element with a specified key and a value to an object and returns an object.  
+
+<br>
+
+## Skeleton
+
+This package was generated by the [library skeleton][skeleton] with [Angular CLI](https://github.com/angular/angular-cli) version 13.0.0.
+
+Copy this package to the `packages/type` folder of the [library skeleton][skeleton] then run the commands below.
+
+<br>
+
+## Code scaffolding
+
+Run `ng generate component component-name --project type` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project type`.
+> Note: Don't forget to add `--project type` or else it will be added to the default project in your `angular.json` file.
+
+### Build
+
+Run `ng build type` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+### Publishing
+
+After building your library with `ng build type`, go to the dist folder `cd dist/type` and run `npm publish`.
+
+### Running unit tests
+
+Install `@angular-package/type` with command:
+
+```typescript
+npm i @angular-package/testing --no-save
+```
+
+Run `ng test type` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+### Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
+
+<br>
+
+## Installation
+
+Install `@angular-package/type` package with command:
+
+```bash
+npm i @angular-package/type --save
+```
+
+<br>
+
+## Api
+
+```typescript
+// Main.
+import {
+  recognizeValue, // From the `5.0.0` version
+  typeOf,
+} from '@angular-package/type';
+```
+
+```typescript
+// `are` prefix functions.
+import {
+  // Function.
+  areBigInt, // From the `5.0.0` version
+  areBoolean, // From the `5.0.0` version
+  areDate, // From the `5.0.0` version
+  areDefined, // From the `5.0.0` version
+  areFalse, // From the `5.0.0` version
+  areNull, // From the `5.0.0` version
+  areNumber, // From the `5.0.0` version
+  areRegExp, // From the `5.0.0` version
+  areString,
+  areSymbol, // From the `5.0.0` version
+  areTrue, // From the `5.0.0` version
+  areUndefined, // From the `5.0.0` version
+} from '@angular-package/type';
+```
 
 ```typescript
 // `guard` prefix functions.
@@ -27,20 +179,32 @@ import {
   guardBigInt,
   guardBoolean,
   guardClass,
+  guardDate, // From the 5.0.0 version
   guardDefined,
+  guardFalse, // From the 5.0.0 version
   guardFunction,
   guardInstance,
   guardKey,
   guardNull,
   guardNumber,
+  guardNumberBetween, // From the 5.0.0 version
   guardObject,
   guardObjectKey,
+  guardObjectKeyIn, // From the 5.0.0 version
   guardObjectKeys,
+  guardObjectKeysIn, // From the 5.0.0 version
+  guardObjectSomeKeys, // From the 5.0.0 version
   guardPrimitive,
+  guardRegExp, // From the 5.0.0 version
   guardString,
+  guardStringIncludes, // From the 5.0.0 version
+  guardStringIncludesSome, // From the 5.0.0 version
+  guardStringLength, // From the 5.0.0 version
+  guardStringLengthBetween, // From the 5.0.0 version
   guardSymbol,
+  guardTrue, // From the 5.0.0 version
   guardType,
-  guardUndefined
+  guardUndefined,
 } from '@angular-package/type'; 
 ```
 
@@ -53,32 +217,37 @@ import {
   isBooleanObject,
   isBooleanType,
   isClass,
+  isDate, // From the 4.2.0 version.
   isDefined,
+  isFalse, // From the 4.2.0 version.
   isFunction,
   isInstance,
   isKey,
   isNull,
   isNumber,
+  isNumberBetween, // From the 4.2.0 version.
   isNumberObject,
   isNumberType,
   isObject,
   isObjectKey,
   isObjectKeyIn,
   isObjectKeys,
+  isObjectKeysIn, // From the 5.0.0 version
+  isObjectSomeKeys, // From the 5.0.0 version
+  isParam,
   isPrimitive,
+  isRegExp, // From the 4.2.0 version.
   isString,
+  isStringIncludes, // From the 5.0.0 version
+  isStringIncludesSome, // From the 5.0.0 version
+  isStringLength, // From the 4.2.0 version.
+  isStringLengthBetween, // From the 5.0.0 version
   isStringObject,
   isStringType,
   isSymbol,
+  isTrue, // From the 4.2.0 version.
   isType,
-  isUndefined
-} from '@angular-package/type';
-```
-
-```typescript
-// `are` prefix functions.
-import {
-  areString
+  isUndefined,
 } from '@angular-package/type';
 ```
 
@@ -96,8 +265,15 @@ import {
 ```
 
 ```typescript
-// Object.
-import { are, guard, is, isNot } from '@angular-package/type';
+// Objects.
+import { are, guard, is, isNot, type } from '@angular-package/type';
+```
+
+```typescript
+// Interfaces.
+import {
+  MinMax
+} from '@angular-package/type';
 ```
 
 ```typescript
@@ -106,3787 +282,400 @@ import {
   AnyBoolean,
   AnyNumber,
   AnyString,
+  CallbackPayload, // From the `5.0.0` version.
   Constructor,
-  CycleHook,
   Defined,
-  Func,
-  Key,
+  ForEachCallback,  // From the `5.0.0` version.
   Never,
   NotUndefined,
+  NumberBetween, // From the `4.2.0` version.
   Primitive,
   Primitives,
-  ResultCallback,
+  ResultCallback, // From the `4.2.0` version
+  StringOfLength, // From the `4.2.0` version.
   Type,
   Types,
+  Undefined
 } from '@angular-package/type';
 ```
 
-## Features
-
-* Checks if
-  * **any** value is
-    * an [`Array`][array] of any type with [`isArray()`](#isarray).
-    * a `bigint` with [`isBigInt()`](#isbigint).
-    * a `boolean` with [`isBoolean()`](#isboolean).
-    * an `object`type and instance of [`Boolean`][boolean] and [`Object`][object] with [`isBooleanObject()`](#isbooleanobject).
-    * a `boolean` type not an instance of [`Boolean`][boolean] and [`Object`][object], and equal to `true` or `false` with [`isBooleanType()`](#isbooleantype).
-    * a `class` with [`isClass()`](#isclass).
-    * a `function` with [`isFunction()`](#isfunction).
-    * a generic type `instance` with [`isInstance()`](#isinstance).
-    * a [`Key`][key] type with [`isKey()`](#iskey).
-    * a `null` with [`isNull()`](#isnull).
-    * a `number` with [`isNumber()`](#isnumber).
-    * an `object` type and instance of [`Number`][number] and [`Object`][object] with [`isNumberObject()`](#isnumberobject).
-    * a `number` type and **not** instance of [`Number`][number] and [`Object`][object] with [`isNumberType()`](#isnumbertype).
-    * a generic type `object` with [`isObject()`](#isobject).
-    * an `object` with its own specified [`Key`][key] with [`isObjectKey()`](#isobjectkey).
-    * an `object` with the [`Key`][key] by using the `in` operator with [`isObjectKeyIn()`](#isobjectkeyin).
-    * an `object` with some of its own specified [`Key`][key] with [`isObjectKeys()`](#isobjectkeys).
-    * a one of the primitive `boolean`, `bigint`, `number`, `string` with [`isPrimitive()`](#isPrimitive).
-    * a `string` with [`isString()`](#isstring).
-    * an `object` type and instance of [`String`][string] and [`Object`][object] with [`isStringObject()`](#isstringobject).
-    * a `string` type and **not** instance of [`String`][string] and [`Object`][object] with [`isStringType()`](#isstringtype).
-    * a `symbol` with [`isSymbol()`](#isSymbol).
-    * a generic type instance, `function`, `object` or primitive type with [`isType()`](#istype).
-    * a `undefined` with [`isUndefined()`](#isundefined).
-  * a generic type value is
-    * defined with [`isDefined()`](#isdefined).
-  * a generic type value is **not**
-    * a `boolean` with [`isNotBoolean()`](#isnotboolean)
-    * a `function` with [`isNotFunction()`](#isnotfunction)
-    * `null` with [`isNotNull()`](#isnotnull)
-    * a `number` with [`isNotNumber()`](#isnotnumber)
-    * a `string` with [`isNotString()`](#isnotstring)
-    * `undefined` with [`isNotUndefined()`](#isnotundefined)
-* Guard the value to be
-  * an [`Array`][array] of a generic type with [`guardArray()`](#guardarray).
-  * a `bigint` with [`guardBigInt()`](#guardbigint).
-  * a `boolean` with [`guardBoolean()`](#guardboolean).
-  * a generic `Class` type [`class`][ts-classes] with [`guardClass()`](#guardclass).
-  * defined with [`guardDefined()`](#guarddefined).
-  * a [`Func`](#func) type with [`guardFunction()`](#guardfunction).
-  * an instance with [`guardInstance()`](#guardinstance).
-  * a `null` with [`guardNull()`](#guardnull).
-  * a [`Key`][key] with [`guardKey()`](#guardkey).
-  * a `number` with [`guardNumber()`](#guardnumber).
-  * an `object` of a generic type with [`guardObject()`](#guardobject).
-  * an `object` of a generic type that contains `key` with [`guardObjectKey()`](#guardobjectkey).
-  * an `object` of a generic type that contains some of its own specified keys with [`guardObjectKeys()`](#guardobjectkeys).
-  * a one of the [`Primitives`](#primitives) with [`guardPrimitive()`](#guardprimitive).
-  * a `string` with [`guardString()`](#guardstring).
-  * a `symbol` with [`guardSymbol()`](#guardsymbol).
-  * a generic type from one of the [`Types`](#types) type with [`guardType()`](#guardtype).
-  * `undefined` with [`guardUndefined()`](#guardundefined).
-
-## How angular-package understands
-
-Check
-> Is to check the inputted value to be **the same** as **expected**.
-
-Type guard
-> Is to guard the parameter type to **not let** input **unexpected** value in the **code editor**.
-
-Guard
-> Is a **combination** of both above to **guard type** in the **code editor** and to check inputted value.
-
-----
-
-* [Installation](#installation)
-* [Skeleton](#skeleton)
-* [Callback](#callback)
-* [Check](#check)
-  * [typeOf()](#typeof)
-  * [are](#are)
-  * [is](#is)
-  * [isNot](#isnot)
-* [Guard](#guard)
-* [Common types](#common-types)
-* [Experimental](#experimental)
-  * [BigIntObject](#bigintobject)
-  * [BooleanObject](#booleanobject)
-  * [NumberObject](#numberobject)
-  * [PrimitiveObject](#primitiveobject)
-  * [StringObject](#stringobject)
-  * [SymbolObject](#symbolobject)
-  * [isParam()](#isparam)
-* [Git](#git)
-  * [Commit](#commit)
-  * [Versioning](#versioning)
-* [License](#license)
-
-----
-
-## Installation
-
-Install `@angular-package/type` package with command:
-
-```bash
-npm i --save @angular-package/type
-```
-
-## Skeleton
-
-This package was built by the [library skeleton][skeleton] which was generated with [Angular CLI](https://github.com/angular/angular-cli) version 12.0.1.
-
-Copy this package to the `packages/type` folder of the [library skeleton][skeleton] then run the commands below.
-
-### Build
-
-Run `ng build type` to build the package. The build artifacts will be stored in the `dist/` directory.
-
-### Running unit tests
-
-Run `ng test type` to execute the unit tests via [Karma](https://karma-runner.github.io).
-
-## Callback
-
-Default function to handle `callback` of [`ResultCallback`][resultcallback] type.
-
-```typescript
-const resultCallback: ResultCallback = (result: boolean): boolean => result
-```
-
-**Parameters:**
-
-| Name: `type`      | Description                                         |
-| :---------------- | :-------------------------------------------------- |
-| result: `boolean` | A `boolean` type value from the result of the check |
-| value?: `any`     | Any type value from the check                       |
-
-**Returns:**
-
-| Returns   | Type      | Description                        |
-| :-------- | :-------: | :--------------------------------- |
-| `boolean` | `boolean` | The **return type** is a `boolean` |
-
-The **return value** is a `boolean` type result from the check.
-
-Custom function to handle `callback`.
-
-```typescript
-const customCallback: ResultCallback = (result: boolean, value: any): boolean => {
-  if (result === false) {
-    throw new Error(`${value} must be a string`);
-  }
-  return result;
-};
-
-const stringResult = isString('Lorem ipsum', customCallback);
-
-```
-
-## Check
-
-### typeOf
-
-Primary and common function in checking the types. [Here](https://javascript.plainenglish.io/the-best-way-to-type-check-in-vanilla-js-55197b4f45ec) is article about how it works.
-
-```typescript
-const typeOf = (value: any): string => Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
-```
-
-----
-
-### are
-
-The object contains prefixed with `are` functions.
-
-```typescript
-const are: Are = {
-  string: areString
-};
-```
-
-----
-
-### areString
-
- Use `areString()` or `are.string()` to check if all the values are `string`.
-
-```typescript
-const areString = (...value: any): boolean => check('string', ...value);
-```
-
-**Parameters:**
-
-| Name: `type`    | Description         |
-| :-------------- | :------------------ |
-| ...value: `any` | A [rest parameter][function-rest-parameter] of any type to check |
-
-**Returns:**
-
-| Returns   | Type      | Description                         |
-| :-------- | :-------: | :---------------------------------  |
-| `boolean` | `boolean` | The **return type** is a `boolean`  |
-
-The **return value** is a `boolean` indicating whether or not all the values are `string`.
-
-**Usage:**
-
-[Example usage on playground][are-string]
-
-----
-
-### is
-
-![update][update]
-
-`4.1.0`: Adds `objectKeys` as [`isObjectKeys()`](#isobjectkeys).
-
-The object contains prefixed with `is` functions and prefixed with `isNot` functions in property `not`.
-
-```typescript
-const is: Is = {
-  array: isArray,
-  bigInt: isBigInt, // deprecated
-  bigint: isBigInt,
-  boolean: isBoolean,
-  booleanObject: isBooleanObject,
-  booleanType: isBooleanType,
-  class: isClass,
-  defined: isDefined,
-  function: isFunction,
-  instance: isInstance,
-  key: isKey,
-  not: isNot,
-  null: isNull,
-  number: isNumber,
-  numberObject: isNumberObject,
-  numberType: isNumberType,
-  object: isObject,
-  objectKey: isObjectKey,
-  objectKeyIn: isObjectKeyIn,
-  objectKeys: isObjectKeys,
-  primitive: isPrimitive,
-  string: isString,
-  stringObject: isStringObject,
-  stringType: isStringType,
-  symbol: isSymbol,
-  type: isType,
-  undefined: isUndefined
-};
-```
-
-----
-
-### isArray
-
-Use `isArray()` or `is.array()` to check if **any** `value` is an [`Array`][array], [`Array`][array] instance, and `object` type.
-
-```typescript
-const isArray: IsArray = <Type = any>(
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is Array<Type> =>
-  callback(
-    typeOf(value) === 'array' &&
-    Array.isArray(value) === true &&
-    value instanceof Array === true &&
-    typeof value === 'object',
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name   | Default value | Description |
-| :----- | :------------ | :---------- |
-| `Type` | `any`         | A generic variable to the return type `value is Array<Type>` |
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns                | Type      | Description                                                       |
-| :--------------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Array<Type>` | `boolean` | By default `Type` variable is equal to `any` and the **return type** is a `boolean` as the result of its statement indicating the `value` is an [`Array`][array] of `any` type |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an [`Array`][array].
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isArray } from '@angular-package/type';
-
-const ARRAY_NUMBER = [1, 2, 3];
-const ARRAY_STRING = ['a', 'b', 'c'];
-
-isArray(ARRAY_NUMBER); // true
-isArray<string>(ARRAY_STRING); // true
-
-```
-
-[Example usage on playground][is-array]
-
-----
-
-### isBigInt
-
-Use `isBigInt()` or `is.bigint()` to check if **any** `value` is a `bigint` type.
-
-```typescript
-const isBigInt: IsBigInt = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is bigint =>
-  callback(typeOf(value) === 'bigint' && typeof value === 'bigint', value);
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns           | Type      | Description                                                       |
-| :---------------- | :-------: | :---------------------------------------------------------------- |
-| `value is bigint` | `boolean` | The **return type** is a `boolean` as the result of its statement |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `bigint`.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isBigInt } from '@angular-package/type';
-
-const BIGINT = 9007199254740991n;
-const NUMBER = 27;
-
-isBigInt(NUMBER); // false
-isBigInt(BIGINT); // true
-
-```
-
-[Example usage on playground][is-bigint] | [How to detect `bigint` type][detect-bigint]
-
-----
-
-### isBoolean
-
-Use `isBoolean()` or `is.boolean()` to check if **any** `value` is a `boolean` type not instance of [`Boolean`][boolean] and [`Object`][object] or `object` type instance of [`Boolean`][boolean] and [`Object`][object].
-
-```typescript
-const isBoolean: IsBoolean = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is boolean =>
-  callback(
-    typeOf(value) === 'boolean' &&
-    (isBooleanType(value) || isBooleanObject(value)),
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns            | Type      | Description                                                       |
-| :----------------- | :-------: | :---------------------------------------------------------------- |
-| `value is boolean` | `boolean` | The **return type** is a `boolean` as the result of its statement |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `boolean` type or [`Boolean`][boolean] instance.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isBoolean } from '@angular-package/type';
-
-const BOOLEAN = false;
-const BOOLEAN_INSTANCE = new Boolean(false);
-
-isBoolean(BOOLEAN); // true
-isBoolean(BOOLEAN_INSTANCE); // true
-
-```
-
-[Example usage on playground][is-boolean] | [How to detect the `boolean` type][detect-boolean]
+<br>
 
-----
+## Changelog
 
-### isBooleanObject
+The **changelog** of this package is based on [*keep a changelog*](https://keepachangelog.com/en/1.0.0/). To read it, click on the [CHANGELOG.md][type-github-changelog] link.
 
-Use `isBooleanObject()` or `is.booleanObject()` to check if **any** `value` is an `object` type and instance of [`Boolean`][boolean] and [`Object`][object].
+> A changelog is a file which contains a curated, chronologically ordered list of notable changes for each version of a project. - [*keep a changelog*](https://keepachangelog.com/en/1.0.0/)
 
-```typescript
-const isBooleanObject: IsBooleanObject = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is Boolean =>
-  callback(
-    typeof value === 'object' &&
-    value instanceof Boolean === true &&
-    value instanceof Object === true,
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
+<br>
 
-**Returns:**
-
-| Returns            | Type      | Description                                                                                                      |
-| :----------------- | :-------: | :--------------------------------------------------------------------------------------------------------------- |
-| `value is Boolean` | `boolean` | The **return type** is a `boolean` as the result of its statement indicating the `value` is [`Boolean`][boolean] |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a [`Boolean`][boolean] instance.
-
-**Usage:**
+## GIT
 
-```typescript
-// Example usage
-import { isBooleanObject } from '@angular-package/type';
+### Commit
 
-const BOOLEAN = false;
-const BOOLEAN_INSTANCE = new Boolean(false);
+* [AngularJS Git Commit Message Conventions][git-commit-angular]
+* [Karma Git Commit Msg][git-commit-karma]
+* [Conventional Commits][git-commit-conventional]
 
-isBooleanObject(BOOLEAN); // false
-isBooleanObject(BOOLEAN_INSTANCE); // true
+### Versioning
 
-```
+[Semantic Versioning 2.0.0][git-semver]
 
-----
+**Given a version number MAJOR.MINOR.PATCH, increment the:**
 
-### isBooleanType
+* MAJOR version when you make incompatible API changes,
+* MINOR version when you add functionality in a backwards-compatible manner, and
+* PATCH version when you make backwards-compatible bug fixes.
 
-Use `isBooleanType()` or `is.booleanType()` to check if **any** `value` is a `boolean` type not an instance of [`Boolean`][boolean] and [`Object`][object], and equal to `true` or `false`.
+Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format.
 
-```typescript
-const isBooleanType: IsBooleanType = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is boolean =>
-  callback(
-    value instanceof Boolean === false &&
-    value instanceof Object === false &&
-    typeof value === 'boolean' &&
-    (value === true || value === false),
-    value
-  );
-```
+**FAQ**
+How should I deal with revisions in the 0.y.z initial development phase?
+>The simplest thing to do is start your initial development release at 0.1.0 and then increment the minor version for each subsequent release.
 
-**Parameters:**
+How do I know when to release 1.0.0?
 
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
+>If your software is being used in production, it should probably already be 1.0.0. If you have a stable API on which users have come to depend, you should be 1.0.0. If you’re worrying a lot about backwards compatibility, you should probably already be 1.0.0.
 
-**Returns:**
+## License
 
-| Returns            | Type      | Description                                                       |
-| :----------------- | :-------: | :---------------------------------------------------------------- |
-| `value is boolean` | `boolean` | The **return type** is a `boolean` as the result of its statement |
+MIT © angular-package ([license][type-license])
 
-The **return value** is a `boolean` indicating whether or not the `value` is a `boolean` type.
+<!-- Funding -->
+[github-badge-sponsor]: https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&link=https://github.com/sponsors/angular-package
+[github-sponsor-link]: https://github.com/sponsors/angular-package
+[patreon-badge]: https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Dsciborrudnicki%26type%3Dpatrons&style=flat
+[patreon-link]: https://patreon.com/sciborrudnicki
 
-**Usage:**
+[angulario]: https://angular.io
+[skeleton]: https://github.com/angular-package/skeleton
 
-```typescript
-// Example usage
-import { isBooleanType } from '@angular-package/type';
+<!-- Update status -->
+[experimental]: https://img.shields.io/badge/-experimental-orange
+[fix]: https://img.shields.io/badge/-fix-red
+[new]: https://img.shields.io/badge/-new-green
+[update]: https://img.shields.io/badge/-update-red
 
-const BOOLEAN = false;
-const BOOLEAN_INSTANCE = new Boolean(false);
+<!-- Discord -->
+[discord-badge]: https://img.shields.io/discord/925168966098386944
+[discord-channel]: https://discord.com/channels/925168966098386944/925168966098386948
 
-isBooleanType(BOOLEAN); // true
-isBooleanType(BOOLEAN_INSTANCE); // false
+<!-- Gitter -->
+[gitter-badge]: https://badges.gitter.im/angularpackage/Lobby.svg
+[gitter-chat]: https://gitter.im/angularpackage/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge
 
-```
+<!-- Twitter -->
+[twitter-badge]: https://img.shields.io/twitter/url?style=social&label=Follow%20%40angularpackage&url=https%3A%2F%2Ftwitter.com%2Fangularpackage
+[twitter-follow]: https://twitter.com/angularpackage
 
-----
+<!-- GIT -->
+[git-semver]: http://semver.org/
+
+<!-- GIT: commit -->
+[git-commit-angular]: https://gist.github.com/stephenparish/9941e89d80e2bc58a153
+[git-commit-karma]: http://karma-runner.github.io/0.10/dev/git-commit-msg.html
+[git-commit-conventional]: https://www.conventionalcommits.org/en/v1.0.0/
+
+<!-- This package: type -->
+  <!-- GitHub: badges -->
+  [type-badge-issues]: https://img.shields.io/github/issues/angular-package/type
+  [type-badge-forks]: https://img.shields.io/github/forks/angular-package/type
+  [type-badge-stars]: https://img.shields.io/github/stars/angular-package/type
+  [type-badge-license]: https://img.shields.io/github/license/angular-package/type
+  <!-- GitHub: badges links -->
+  [type-issues]: https://github.com/angular-package/type/issues
+  [type-forks]: https://github.com/angular-package/type/network
+  [type-license]: https://github.com/angular-package/type/blob/master/LICENSE
+  [type-stars]: https://github.com/angular-package/type/stargazers
+  <!-- This package -->
+  [type-github-changelog]: https://github.com/angular-package/type/blob/main/CHANGELOG.md
+
+<!-- Package: callback -->
+  <!-- npm -->
+  [callback-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fcallback.svg
+  [callback-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Fcallback.png
+  [callback-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fcallback
+  [callback-npm-readme]: https://www.npmjs.com/package/@angular-package/callback#readme
+
+  <!-- GitHub -->
+  [callback-github-readme]: https://github.com/angular-package/callback#readme
+
+  [package-callback-callbackpayload]: https://github.com/angular-package/callback#callbackpayload
+  [package-callback-resultcallback]: https://github.com/angular-package/callback#resultcallback
+
+<!-- Package: change-detection -->
+  <!-- npm -->
+  [cd-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fchange-detection.svg
+  [cd-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Fchange-detection.png
+  [cd-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fchange-detection
+  [cd-npm-readme]: https://www.npmjs.com/package/@angular-package/change-detection#readme
+
+  <!-- GitHub -->
+  [cd-github-readme]: https://github.com/angular-package/change-detection#readme
+
+<!-- Package: component-loader -->
+  <!-- npm -->
+  [cl-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fcomponent-loader.svg
+  [cl-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Fcomponent-loader.png
+  [cl-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fcomponent-loader
+  [cl-npm-readme]: https://www.npmjs.com/package/@angular-package/component-loader#readme
+
+  <!-- GitHub -->
+  [cl-github-readme]: https://github.com/angular-package/component-loader#readme
+
+<!-- Package: core -->
+  <!-- npm -->
+  [core-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fcore.svg
+  [core-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Fcore.png
+  [core-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fcore
+  [core-npm-readme]: https://www.npmjs.com/package/@angular-package/core#readme
+
+  <!-- GitHub -->
+  [core-github-readme]: https://github.com/angular-package/core#readme
+
+<!-- Package: error -->
+  <!-- npm -->
+  [error-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Ferror.svg
+  [error-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Ferror.png
+  [error-npm-badge]: https://badge.fury.io/js/%40angular-package%2Ferror
+  [error-npm-readme]: https://www.npmjs.com/package/@angular-package/error#readme
+
+  <!-- GitHub -->
+  [error-github-readme]: https://github.com/angular-package/error#readme
+
+<!-- Package: name -->
+  <!-- npm -->
+  [name-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fname.svg
+  [name-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Fname.png
+  [name-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fname
+  [name-npm-readme]: https://www.npmjs.com/package/@angular-package/name#readme
+
+  <!-- GitHub -->
+  [name-github-readme]: https://github.com/angular-package/name#readme
+
+<!-- Package: preferences -->
+  <!-- npm -->
+  [preferences-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fpreferences.svg
+  [preferences-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Fpreferences.png
+  [preferences-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fpreferences
+  [preferences-npm-readme]: https://www.npmjs.com/package/@angular-package/preferences#readme
+
+  <!-- GitHub -->
+  [preferences-github-readme]: https://github.com/angular-package/preferences#readme
+
+<!-- Package: prism -->
+  <!-- npm -->
+  [prism-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fprism.svg
+  [prism-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Fprism.png
+  [prism-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fprism
+  [prism-npm-readme]: https://www.npmjs.com/package/@angular-package/prism#readme
+
+  <!-- GitHub -->
+  [prism-github-readme]: https://github.com/angular-package/prism#readme
+
+<!-- Package: property -->
+  <!-- npm -->
+  [property-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fproperty.svg
+  [property-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Fproperty.png
+  [property-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fproperty
+  [property-npm-readme]: https://www.npmjs.com/package/@angular-package/property#readme
+
+  <!-- GitHub -->
+  [property-github-readme]: https://github.com/angular-package/property#readme
+
+<!-- Package: range -->
+  <!-- npm -->
+  [range-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Frange.svg
+  [range-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Frange.png
+  [range-npm-badge]: https://badge.fury.io/js/%40angular-package%2Frange
+  [range-npm-readme]: https://www.npmjs.com/package/@angular-package/range#readme
+
+  <!-- GitHub -->
+  [range-github-readme]: https://github.com/angular-package/range#readme
+
+<!-- Package: reactive -->
+  <!-- npm -->
+  [reactive-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Freactive.svg
+  [reactive-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Freactive.png
+  [reactive-npm-badge]: https://badge.fury.io/js/%40angular-package%2Freactive
+  [reactive-npm-readme]: https://www.npmjs.com/package/@angular-package/reactive#readme
+
+  <!-- GitHub -->
+  [reactive-github-readme]: https://github.com/angular-package/reactive#readme
+
+<!-- Package: storage -->
+  <!-- npm -->
+  [storage-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fstorage.svg
+  [storage-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Fstorage.png
+  [storage-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fstorage
+  [storage-npm-readme]: https://www.npmjs.com/package/@angular-package/storage#readme
+
+  <!-- GitHub -->
+  [storage-github-readme]: https://github.com/angular-package/storage#readme
+
+<!-- Package: tag -->
+  <!-- npm -->
+  [tag-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Ftag.svg
+  [tag-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Ftag.png
+  [tag-npm-badge]: https://badge.fury.io/js/%40angular-package%2Ftag
+  [tag-npm-readme]: https://www.npmjs.com/package/@angular-package/tag#readme
+
+  <!-- GitHub -->
+  [tag-github-readme]: https://github.com/angular-package/tag#readme
+
+<!-- Package: testing -->
+  <!-- npm -->
+  [testing-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Ftesting.svg
+  [testing-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Ftesting.png
+  [testing-npm-badge]: https://badge.fury.io/js/%40angular-package%2Ftesting
+  [testing-npm-readme]: https://www.npmjs.com/package/@angular-package/testing#readme
+
+  <!-- GitHub -->
+  [testing-github-readme]: https://github.com/angular-package/testing#readme
+
+<!-- Package: text -->
+  <!-- npm -->
+  [text-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Ftext.svg
+  [text-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Ftext.png
+  [text-npm-badge]: https://badge.fury.io/js/%40angular-package%2Ftext
+  [text-npm-readme]: https://www.npmjs.com/package/@angular-package/text#readme
+
+  <!-- GitHub -->
+  [text-github-readme]: https://github.com/angular-package/text#readme
+
+<!-- Package: type -->
+  <!-- npm -->
+  [type-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Ftype.svg
+  [type-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Ftype.png
+  [type-npm-badge]: https://badge.fury.io/js/%40angular-package%2Ftype
+  [type-npm-readme]: https://www.npmjs.com/package/@angular-package/type#readme
+
+  <!-- GitHub -->
+  [type-github-readme]: https://github.com/angular-package/type#readme
+
+<!-- Package: ui -->
+  <!-- npm -->
+  [ui-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fui.svg
+  [ui-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fui.svg
+  [ui-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fui
+  [ui-npm-readme]: https://www.npmjs.com/package/@angular-package/ui#readme
+
+  <!-- GitHub -->
+  [ui-github-readme]: https://github.com/angular-package/ui#readme
+
+<!-- Package: wrapper -->
+  <!-- npm -->
+  [wrapper-npm-badge-svg]: https://badge.fury.io/js/%40angular-package%2Fwrapper.svg
+  [wrapper-npm-badge-png]: https://badge.fury.io/js/%40angular-package%2Fwrapper.png
+  [wrapper-npm-badge]: https://badge.fury.io/js/%40angular-package%2Fwrapper
+  [wrapper-npm-readme]: https://www.npmjs.com/package/@angular-package/wrapper#readme
+
+  <!-- GitHub -->
+  [wrapper-github-readme]: https://github.com/angular-package/wrapper#readme
+
+<!-- Angular -->
+[angular-component-factory-resolver]: https://angular.io/api/core/ComponentFactoryResolver
+[angular-view-container-ref]: https://angular.io/api/core/ViewContainerRef
+[angular-component-ref]: https://angular.io/api/core/ComponentRef
+
+<!-- Angular -->
+[angular-component-factory-resolver]: https://angular.io/api/core/ComponentFactoryResolver
+[angular-view-container-ref]: https://angular.io/api/core/ViewContainerRef
+
+<!-- Jasmine -->
+[jasmine-describe]: https://jasmine.github.io/api/3.8/global.html#describe
+[jasmine-expect]: https://jasmine.github.io/api/3.8/global.html#expect
+[jasmine-it]: https://jasmine.github.io/api/3.8/global.html#it
+[jasmine-matchers]: https://jasmine.github.io/api/3.9/matchers.html
 
-### isClass
+<!-- Javascript  -->
+[js-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
+[js-array-every]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every
+[js-array-some]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some
 
-Use `isClass()` or `is.class()` to check if **any** `value` is a `function` type, an instance of [`Function`][function] and [`Object`][object] as a generic `Class` type of [`class`][ts-classes]. It also **confirms** with the regexp that function is a [`class`][ts-classes].
+[js-bigint]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt
+[js-bigintconstructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/BigInt
+[js-boolean]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+[js-booleanconstructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/Boolean
 
-```typescript
-const isClass: IsClass = <Class = Function>(
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is Class =>
-  callback(
-    typeOf(value) === 'function' &&
-      typeof value === 'function' &&
-      value instanceof Function === true &&
-      value instanceof Object === true
-      ? /class/.test(Function.prototype.toString.call(value).slice(0, 5))
-      : false,
-    value
-  );
-```
+[js-classes]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes
 
-**Generic type variables:**
+[js-date]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
 
-| Name    | Default value | Description |
-| :------ | :------------ | :---------- |
-| `Class` | `Function`    | A generic variable to the return type `value is Class` |
+[js-error]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
 
-**Parameters:**
+[js-function]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions
 
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
+[js-getter]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get
 
-**Returns:**
+[js-hasownproperty]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
 
-| Returns          | Type      | Description                                                       |
-| :--------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Class` | `boolean` | By default `Class` variable is equal to [`Function`][function] and the **return type** is a `boolean` as the result of its statement indicating the `value` is a [`Function`][function] |
+[js-instanceof]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof
+[js-in-operator]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/in
+[js-isarray]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
+[js-isfinite]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite
+[js-isfrozen]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen
+[js-isnan]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN
 
-The **return value** is a `boolean` indicating whether or not the `value` is a [`class`][ts-classes].
+[js-map]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
 
-**Usage:**
+[js-null]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
+[js-number]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number
+[js-numberconstructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/Number
+[js-numberisfinite]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite
+[js-numberisinteger]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
+[js-numberisnan]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN
+[js-numberissafeinteger]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger
 
-```typescript
-// Example usage
-import { isClass } from '@angular-package/type';
+[js-object]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object
+[js-object-define-property]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty
+[js-object-getownpropertydescriptor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
+[js-object-getOwnpropertydescriptors]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors
 
-class Class { x = 5; }
-const FUNC: Func = (x: number): any => x + 5;
+[js-primitive]: https://developer.mozilla.org/en-US/docs/Glossary/Primitive
+[js-promise]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
 
-isClass(Class); // true
-isClass(FUNC); // false
-isClass(() => 5); // false
+[js-rangeerror]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError
+[js-referenceerror]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError
+[js-regexp]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp
+[js-rest-parameter]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters
 
-```
+[js-set]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
+[js-setter]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/set
+[js-static]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/static
+[js-storage]: https://developer.mozilla.org/en-US/docs/Web/API/Storage
+[js-string]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String
+[js-stringconstructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/String
+[js-symbol]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol
+[js-symbolconstructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/Symbol
+[js-syntaxerror]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError
 
-----
+[js-tostring]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString
+[js-typeerror]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError
+[js-typeof]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof
 
-### isDefined
+[js-undefined]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
+[js-urlerror]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError
 
-![fix][fix]
+[js-weakset]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet
 
-`4.1.3`: Fixes the return type `boolean`, which doesn't strictly indicate the `value` is defined by changing the `value` type to a generic `Type` and the return type to `value is Defined<Type>`.
+<!-- Karma -->
+[karma]: http://karma-runner.github.io/0.10/index.html
 
-Use `isDefined()` or `is.defined()` to check if a generic `Type` `value` is **not** an `undefined` type and is **not** equal to `undefined`.
-
-```typescript
-const isDefined: IsDefined = <Type>(
-  value: Type,
-  callback: ResultCallback = resultCallback
-): value is Defined<Type> =>
-  callback(
-    typeOf(value) !== 'undefined' &&
-    typeof value !== 'undefined' &&
-    value !== undefined,
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name   | Default value    | Description                                                           |
-| :----- | :--------------- | :-------------------------------------------------------------------- |
-| `Type` | From the `value` | A generic `Type` variable to the return type `value is Defined<Type>` |
-
-**Parameters:**
-
-| Name: `type`               | Description                                                                      |
-| :------------------------- | :------------------------------------------------------------------------------- |
-| value: `Type`              | A generic `Type` `value`, by default of type detected from the `value`, to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns                  | Type      | Description                         |
-| :----------------------- | :-------: | :---------------------------------- |
-| `value is Defined<Type>` | `boolean` | By default `Type` variable is equal to the type detected from the `value`, but the detected type `undefined` changes to `never` and the **return type** is a `boolean` as the result of its statement `value` is [`Defined<Type>`][type-defined] |
-
-The **return value** is a `boolean` indicating whether or not the `value` is defined, not `undefined`
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isDefined } from '@angular-package/type';
-
-const UNDEFINED = undefined;
-let defined;
-
-isDefined(UNDEFINED); // false
-isDefined(defined); // false
-
-```
-
-----
-
-### isFunction
-
-Use `isFunction()` or `is.function()` to check if **any** `value` is a `function` type, an instance of [`Function`][function] and [`Object`][object]. It also **denies** with the regexp that function is a [`class`][ts-classes].
-
-```typescript
-const isFunction: IsFunction = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is Func =>
-  callback(
-    typeOf(value) === 'function' &&
-      typeof value === 'function' &&
-      value instanceof Function === true &&
-      value instanceof Object === true
-      ? /class/.test(Function.prototype.toString.call(value).slice(0, 5)) ===
-      false
-      : false,
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns          | Type      | Description                                                       |
-| :--------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Func`  | `boolean` | The **return type** is a `boolean` as the result of its statement indicating the `value` is a [`Func`](#func) |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `function`.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isFunction } from '@angular-package/type';
-
-type Func = (...param: any) => any;
-class Class { x = 5; }
-const FUNC: Func = (x: number): any => x + 5;
-
-isFunction(Class); // true
-isFunction(FUNC); // true
-isFunction(() => 5); // true
-
-```
-
-[Example usage on playground][is-function] | [How to detect `function` type][detect-function]
-
-----
-
-### isInstance
-
-![update][update]
-
-`4.1.1`:
-
-* Changes the `Class` type variable name to `Obj`.
-* Changes the `className` parameter name to `constructor` cause it represents [`class`][ts-classes] or [`function`][ts-function] constructor.
-* Fixes type variable `Obj` default value is set to [`Function`][function] by removing it cause it's always being picked from the `constructor` parameter.
-* Removes unnecessary [`Constructor`][constructor] from the return type.
-* Adds check `constructor` against the [`function`][ts-function].
-
-Use `isInstance()` or `is.instance()` to check if **any** value is an `object` of a generic `Obj` type and an instance of [`Constructor`][constructor] type.
-
-```typescript
-const isInstance: IsInstance = <Obj>(
-  value: any,
-  constructor: Constructor<Obj>,
-  callback: ResultCallback = resultCallback
-): value is Obj =>
-  callback(
-    isObject<Obj>(value)
-      ? isClass<Obj>(constructor) || isFunction(constructor)
-        ? value instanceof constructor === true
-        : false
-      : false,
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name  | Default value          | Description                                          |
-| :---- | :--------------------- | :--------------------------------------------------- |
-| `Obj` | From the `constructor` | A generic variable to the return type `value is Obj` |
-
-**Parameters:**
-
-| Name: `type`                    | Description                                        |
-| :------------------------------ | :------------------------------------------------- |
-| value: `any`                    | Any `value` to be an instance of the `constructor` |
-| constructor: `Constructor<Obj>` | A [`class`][ts-classes] or [`function`][ts-function] that specifies the type of the [`Constructor`][constructor] |
-| callback: `ResultCallback`      | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns        | Type      | Description                                                                                                                            |
-| :------------- | :-------: | :------------------------------------------------------------------------------------------------------------------------------------- |
-| `value is Obj` | `boolean` | The **return type** is a `boolean` as the result of its statement indicating the `value` is `Obj` from the detected `constructor` type |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an instance of a generic `Obj`.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isInstance } from '@angular-package/type';
-
-// Classes.
-class Some { x = 127; }
-class Two { y = 'Lorem ipsum'; }
-
-const SOME = new Some();
-const TWO = new Two();
-
-isInstance<Some>(TWO, Some); // false
-isInstance<Some>(SOME, Some); // true
-isInstance<Some>(TWO, Two); // true and type error
-
-// Function constructor.
-function functionConstructor(this: any, ...args: any[]): any {
-  if (args) {
-    args.forEach((arg, index: number) => this[index] = arg[index]);
-  }
-  return this;
-}
-
-const anyInstance: any = new (functionConstructor as any)('First name', 'Sur name', 27);
-
-isInstance(anyInstance, functionConstructor as any); // true
-
-```
-
-[Example usage on playground][is-instance] | [How to detect `constructor` instance][detect-instance]
-
-----
-
-### isKey
-
-![update][update]
-
-`4.1.0`: Checks only for primitive `string` and `number`.
-
-Use `isKey()` or `is.key()` to check if **any** `value` is one of the `string`, `number`, or `symbol`.
-
-```typescript
-const isKey: IsKey = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is Key =>
-  callback(
-    isStringType(value) || isNumberType(value) || isSymbol(value),
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns         | Type      | Description                                                                                              |
-| :-------------- | :-------: | :------------------------------------------------------------------------------------------------------- |
-| `value is Key`  | `boolean` | The **return type** is a `boolean` as the result of its statement indicating the `value` is [`Key`][key] |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a [`Key`][key].
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isKey } from '@angular-package/type';
-
-const STRING = 'surname';
-const STRING_INSTANCE = new String(STRING);
-isKey(STRING); // true
-isKey(STRING_INSTANCE); // true
-
-const NUMBER = 27;
-const NUMBER_INSTANCE = new Number(NUMBER);
-isKey(NUMBER); // true
-isKey(NUMBER_INSTANCE); // true
-
-const SYMBOL_NUMBER: unique symbol = Symbol(NUMBER);
-const SYMBOL_STRING: unique symbol = Symbol(STRING);
-isKey(SYMBOL_NUMBER); // true
-isKey(SYMBOL_STRING); // true
-
-```
-
-----
-
-### isNull
-
-Use `isNull()` or `is.null()` to check if **any** `value` is an `object` type and equal to `null`.
-
-```typescript
-const isNull: IsNull = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is null =>
-  callback(
-    typeOf(value) === 'null' && typeof value === 'object' && value === null,
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- |--------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns         | Type      | Description                                                       |
-| :-------------- | :-------: | :---------------------------------------------------------------- |
-| `value is null` | `boolean` | The **return type** is a `boolean` as the result of its statement |
-
-The **return value** is a `boolean` indicating whether or not the `value` is `null`.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isNull } from '@angular-package/type';
-
-/**
- * typeof === 'object'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-const NULL: any = null;
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-const NUMBER = 27;
-
-isNull(NULL); // true
-isNull(NUMBER); // false
-
-```
-
-[Example usage on playground][is-null] | [How to detect `null` type][detect-null]
-
-----
-
-### isNumber
-
-Use `isNumber()` or `is.number()` to check if **any** `value` is a `number` type not an instance of [`Number`][number] and [`Object`][object] or `object` type instance of [`Number`][number] and [`Object`][object].
-
-```typescript
-const isNumber: IsNumber = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is number =>
-  callback(
-    typeOf(value) === 'number' &&
-    isFinite(value) === true &&
-    (isNumberType(value) || isNumberObject(value)),
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns           | Type      | Description                                                       |
-| :---------------- | :-------: | :---------------------------------------------------------------- |
-| `value is number` | `boolean` | The **return type** is a `boolean` as the result of its statement |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `number` type or [`Number`][number] instance.
-
-**Usage:**
-
-[Example usage on playground][is-number] | [How to detect a `number` type][detect-number]
-
-----
-
-### isNumberObject
-
-Use `isNumberObject()` or `is.numberObject()` to check if **any** `value` is an `object` type and instance of [`Number`][number] and [`Object`][object].
-
-```typescript
-const isNumberObject: IsNumberObject = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is Number =>
-  callback(
-    typeof value === 'object' &&
-    value instanceof Number === true &&
-    value instanceof Object === true,
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns           | Type      | Description                                                                                                    |
-| :---------------- | :-------: | :------------------------------------------------------------------------------------------------------------- |
-| `value is Number` | `boolean` | The **return type** is a `boolean` as the result of its statement indicating the `value` is [`Number`][number] |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a [`Number`][number] instance.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isNumberObject } from '@angular-package/type';
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-const NUMBER = 10304050;
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-const NUMBER_INSTANCE = Number(NUMBER);
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === true
- * instanceof Object === true
- */
-const NUMBER_NEW_INSTANCE = new Number(NUMBER);
-
-isNumberObject(NUMBER); // false
-isNumberObject(NUMBER_INSTANCE); // false
-isNumberObject(NUMBER_NEW_INSTANCE); // true
-
-```
-
-----
-
-### isNumberType
-
-Use `isNumberType()` or `is.numberType()` to check if **any** `value` is a `number` type not an instance of [`Number`][number] and [`Object`][object].
-
-```typescript
-const isNumberType: IsNumberType = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is number =>
-  callback(
-    value instanceof Number === false &&
-    value instanceof Object === false &&
-    typeof value === 'number',
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns           | Type      | Description                                                       |
-| :---------------- | :-------: | :---------------------------------------------------------------- |
-| `value is number` | `boolean` | The **return type** is a `boolean` as the result of its statement |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `number` type.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isNumberType } from '@angular-package/type';
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-const NUMBER = 10304050;
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-const NUMBER_INSTANCE = Number(NUMBER);
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === true
- * instanceof Object === true
- */
-const NUMBER_NEW_INSTANCE = new Number(NUMBER);
-
-isNumberType(NUMBER); // true
-isNumberType(NUMBER_INSTANCE); // true
-isNumberType(NUMBER_NEW_INSTANCE); // false
-
-```
-
-----
-
-### isObject
-
-Use `isObject()` or `is.object()` to check if **any** `value` is an `object` of a generic `Obj` type and [`Object`][object] instance.
-
-```typescript
-const isObject: IsObject = <Obj = object>(
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is Obj =>
-  callback(
-    typeOf(value) === 'object' &&
-    typeof value === 'object' &&
-    value instanceof Object === true,
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name  | Default value | Description |
-| :---- | :------------ | :---------- |
-| `Obj` | `object`      | A generic variable to the return type `value is Obj` |
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns        | Type        | Description                                                            |
-| :------------- | :---------: | :--------------------------------------------------------------------- |
-| `value is Obj` | `boolean`   | By default `Obj` variable is equal to `object` and the **return type** is a `boolean` as the result of its statement indicating the `value` is `object` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an `object`.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isObject } from '@angular-package/type';
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-const x = 10304050;
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-const NUMBER = 10304050;
-
-/**
- * typeof === 'string'
- * instanceof Function === false
- * instanceof Object === false
- * instanceof String === false
- */
-const STRING = '!@#$%^&*()abcdefghijklmnoprstuwyz';
-
-const SYMBOL_NUMBER: unique symbol = Symbol(NUMBER);
-const SYMBOL_STRING: unique symbol = Symbol(STRING);
-
-interface ObjectOne {
-  'key as string'?: boolean;
-  1030405027?: string;
-  5?: string;
-  [number]: number;
-  [STRING]: string;
-  [SYMBOL_NUMBER]?: string;
-  [SYMBOL_STRING]?: number;
-  x: number;
-}
-
-const OBJECT_ONE: ObjectOne = {
-  'key as string': true,
-  1030405027: 'key is number',
-  5: 'key is also number',
-  [number]: NUMBER,
-  [STRING]: 'key is string',
-  [SYMBOL_NUMBER]: 'key is symbol number',
-  [SYMBOL_STRING]: 6,
-  x: 3000
-};
-
-isObject(OBJECT_ONE); // true
-
-```
-
-[Example usage on playground][is-object] | [How to detect an `object` type][detect-object]
-
-----
-
-### isObjectKey
-
-Use `isObjectKey()` or `is.objectKey()` to check if **any** `value` is an `object` with its own specified keys of the [`Key`][key].
-The function uses [`hasOwnProperty`][hasownproperty] [`Object`][object] method to finds enumerable and non-enumerable [`Key`][key] as `string`, `number`, `symbol` unlike `Object.keys()` but it can't find accessor descriptor property unlike `in` operator, which can.
-
-```typescript
-const isObjectKey: IsObjectKey = <Type = object>(
-  value: any,
-  key: Key | Key[],
-  callback: ResultCallback = resultCallback
-): value is Type =>
-  callback(
-    isObject<Type>(value)
-      ? isArray(key)
-        ? key.every((k) =>
-          isKey(k) ? {}.hasOwnProperty.call(value, k) === true : false
-        )
-        : isKey(key)
-          ? {}.hasOwnProperty.call(value, key)
-          : false
-      : false,
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name   | Default value | Description |
-| :----- | :------------ | :---------- |
-| `Type` | `object`      | A generic variable to the return type `value is Type` |
-
-**Parameters:**
-
-| Name: `type`               | Description                                           |
-| :------------------------- | :---------------------------------------------------- |
-| value: `any`               | Any `value` to check if it contains a specified `key` |
-| key: `Key \| Key[]`        | A [`Key`][key] type or an array of [`Key`][key] type to check in the `value` |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns         | Type      | Description                                                            |
-| :-------------- | :-------: | :--------------------------------------------------------------------- |
-| `value is Type` | `boolean` | By default `Type` variable is equal to `object` and the **return type** is a `boolean` as the result of its statement indicating the `value` is `object` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an `object` with its own specified keys.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isObjectKey } from '@angular-package/type';
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-const NUMBER = 10304050;
-
- /**
-  * typeof === 'string'
-  * instanceof Function === false
-  * instanceof Object === false
-  * instanceof String === false
-  */
-const STRING = '!@#$%^&*()abcdefghijklmnoprstuwyz';
-
-const SYMBOL_NUMBER: unique symbol = Symbol(NUMBER);
-const SYMBOL_STRING: unique symbol = Symbol(STRING);
-
-interface ObjectOne {
-  'key as string'?: boolean;
-  1030405027?: string;
-  5?: string;
-  [number]: number;
-  [STRING]: string;
-  [SYMBOL_NUMBER]?: string;
-  [SYMBOL_STRING]?: number;
-  x: number;
-}
-
-/**
- * typeof === 'object'
- * instanceof Boolean === false
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === true
- * instanceof String === false
- * instanceof Symbol === false
- */
-const OBJECT_ONE: ObjectOne = {
-  'key as string': true,
-  1030405027: 'key is number',
-  5: 'key is also number',
-  [number]: NUMBER,
-  [STRING]: 'key is string',
-  [SYMBOL_NUMBER]: 'key is symbol number',
-  [SYMBOL_STRING]: 6,
-  x: 3000
-};
-
-isObjectKey(OBJECT_ONE, STRING); // true
-isObjectKey(OBJECT_ONE, 1030405027); // true
-isObjectKey(OBJECT_ONE, NUMBER); // true
-isObjectKey(OBJECT_ONE, SYMBOL_NUMBER); // true
-isObjectKey(OBJECT_ONE, SYMBOL_STRING); // true
-
-/**
- * typeof === 'function'
- * instanceof Class === false
- * instanceof Function === true
- * instanceof Object === true
- */
-class Class {
-
-  1030405027 = 'my new number';
-  5 = 'my number';
-
-  firstName = 'My name';
-  surname = 'Surname';
-
-  x = NUMBER;
-  y = STRING;
-
-  get [number](): number {
-    return this.x;
-  }
-  get [STRING](): string {
-    return this.y;
-  }
-
-  get [SYMBOL_NUMBER](): number {
-    return this.x;
-  }
-
-  get [SYMBOL_STRING](): string {
-    return this.y;
-  }
-}
-
-/**
- * typeof === 'object'
- * instanceof Class === true
- * instanceof Function === false
- * instanceof Object === true
- */
-const CLASS = new Class();
-
-// One of the differences between the `in` operator and the `hasOwnProperty()` method is that it doesn't find a getter key
-isObjectKey(CLASS, SYMBOL_NUMBER); // false
-isObjectKey(CLASS, SYMBOL_STRING); // false
-isObjectKey(CLASS, [SYMBOL_NUMBER, SYMBOL_STRING]); // false
-
-```
-
-----
-
-### isObjectKeyIn
-
-Use `isObjectKeyIn()` or `is.objectKeyIn()` to check if **any** `value` is an [`Object`][object] with the `key` of the [`Key`][key] type by using the `in` operator. The function uses operator [`in`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/in) to find the key.
-
-```typescript
-const isObjectKeyIn: IsObjectKeyIn = <Type = object>(
-  value: any,
-  key: Key | Key[],
-  callback: ResultCallback = resultCallback
-): value is Type =>
-  callback(
-    isObject<Type>(value)
-      ? isArray(key)
-        ? key.every((k) => (isKey(k) ? k in value : false))
-        : isKey(key)
-          ? key in value
-          : false
-      : false,
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name   | Default value | Description |
-| :----- | :------------ | :---------- |
-| `Type` | `object`      | A generic variable to the return type `value is Type` |
-
-**Parameters:**
-
-| Name: `type`               | Description                                                                  |
-| :------------------------- | :--------------------------------------------------------------------------- |
-| value: `any`               | Any `value` to check if it contains a specified `key`                        |
-| key: `Key \| Key[]`        | A [`Key`][key] type or an array of [`Key`][key] type to check in the `value` |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns         | Type      | Description                                                            |
-| :-------------- | :-------: | :--------------------------------------------------------------------- |
-| `value is Type` | `boolean` | By default `Type` variable is equal to `object` and the **return type** is a `boolean` as the result of its statement indicating the `value` is `object` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an `object` with the keys.
-
-**Usage:**
-
-```typescript
-import { isObjectKeyIn } from '@angular-package/type';
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-const NUMBER = 10304050;
-
-/**
- * typeof === 'string'
- * instanceof Function === false
- * instanceof Object === false
- * instanceof String === false
- */
-const STRING = '!@#$%^&*()abcdefghijklmnoprstuwyz';
-
-/**
- * typeof === 'symbol'
- * instanceof Boolean === false
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- * instanceof String === false
- * instanceof Symbol === false
- */
-const SYMBOL_NUMBER: unique symbol = Symbol(NUMBER);
-const SYMBOL_STRING: unique symbol = Symbol(STRING);
-
-/**
- * typeof === 'function'
- * instanceof Class === false
- * instanceof Function === true
- * instanceof Object === true
- */
-class Class {
-
-   1030405027 = 'my new number';
-   5 = 'my number';
-
-   firstName = 'My name';
-   surname = 'Surname';
-
-   x = NUMBER;
-   y = STRING;
-
-   get [number](): number {
-     return this.x;
-   }
-   get [STRING](): string {
-     return this.y;
-   }
-
-   get [SYMBOL_NUMBER](): number {
-     return this.x;
-   }
-
-   get [SYMBOL_STRING](): string {
-     return this.y;
-   }
-}
-
-/**
- * typeof === 'object'
- * instanceof Class === true
- * instanceof Function === false
- * instanceof Object === true
- */
-const CLASS = new Class();
-
-// One of the differences between `in` operator and the `hasOwnProperty()` method is that it finds a getter key
-isObjectKeyIn(CLASS, SYMBOL_NUMBER); // true
-isObjectKeyIn(CLASS, SYMBOL_STRING); // true
-isObjectKeyIn(CLASS, [SYMBOL_NUMBER, SYMBOL_STRING]); // true
-
-```
-
-----
-
-### isObjectKeys
-
-![new][new]
-
-Use `isObjectKeys()` or `is.objectKeys()` to check if **any** `value` is an `object` with **some** its own specified keys of the [`Key`][key].
-Cause of using [`some()`][array-some] on the [rest parameter][function-rest-parameter] `...keys` each of its argument is treated as logic `or`, and cause of using [`every()`][array-every] on its array argument each of array item is treated as logic `and`.
-Simply, in the usage section below the function finds in the object `get` and `set` or `writable` and `value`, which means the object contains `get` and `set` or `writable` and `value`.
-The function uses [`hasOwnProperty`][hasownproperty] [`Object`][object] method to finds enumerable and non-enumerable [`Key`][key] as `string`, `number`, `symbol` unlike `Object.keys()` but it can't find accessor descriptor property unlike `in` operator, which can.
-
-```typescript
-const isObjectKeys: IsObjectKeys = <Type = object>(
-  value: any,
-  ...keys: (Key | Array<Key>)[]
-): value is Type =>
-  isObject<Type>(value)
-    ? keys.some((key) =>
-      isArray(key)
-        ? key.every((k) =>
-          isKey(k) ? {}.hasOwnProperty.call(value, k) === true : false
-        )
-        : isKey(key)
-          ? {}.hasOwnProperty.call(value, key) === true
-          : false
-    )
-    : false;
-```
-
-**Generic type variables:**
-
-| Name   | Default value | Description |
-| :----- | :------------ | :---------- |
-| `Type` | `object`      | A generic variable to the return type `value is Type` |
-
-**Parameters:**
-
-| Name: `type`                     | Description                                                                                 |
-| :------------------------------- | :------------------------------------------------------------------------------------------ |
-| value: `any`                     | Any `value` to check if it contains **some** of the specified `keys`                        |
-| ...keys: `(Key \| Array<Key>)[]` | A [rest parameter][function-rest-parameter] single [`Key`][key] type or an array of [`Key`][key] type to check in the `value` |
-
-**Returns:**
-
-| Returns         | Type      | Description                                                            |
-| :-------------- | :-------: | :--------------------------------------------------------------------- |
-| `value is Type` | `boolean` | By default `Type` variable is equal to `object` and the **return type** is a `boolean` as the result of its statement indicating the `value` is `object` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an `object` with some its own specified keys.
-
-**Usage:**
-
-```typescript
-// Real example usage from incoming @angular-package/property.
-interface CommonDescriptor extends Pick<PropertyDescriptor, 'configurable' | 'enumerable'> {}
-interface AccessorDescriptor<Value> extends CommonDescriptor {
-  get: (() => Value) | undefined;
-  set: ((value: Value) => void) | undefined;
-}
-interface DataDescriptor<Value> extends CommonDescriptor {
-  writable: boolean;
-  value: Value;
-}
-type ThisAccessorDescriptor<Value, Obj = any> = AccessorDescriptor<Value> & ThisType<Obj>;
-
-const ACCESSOR_DESCRIPTOR: ThisAccessorDescriptor<string | undefined, ObjectOne> =  {
-  configurable: true,
-  enumerable: true,
-  get(): string | undefined {
-    return this[5];
-  },
-  set(value: string | undefined) {
-    this[5] = value;
-  }
-}
-
-const DATA_DESCRIPTOR: DataDescriptor<string> = {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: 'my value'
-}
-
-isObjectKeys(ACCESSOR_DESCRIPTOR, ['writable', 'value'], ['get', 'set']); // true
-isObjectKeys(ACCESSOR_DESCRIPTOR, ['writable', 'value']); // false
-isObjectKeys(ACCESSOR_DESCRIPTOR, 'writable', 'value'); // false
-isObjectKeys(ACCESSOR_DESCRIPTOR, ['get', 'set']); // true
-isObjectKeys(ACCESSOR_DESCRIPTOR, 'get', 'set'); // true
-
-isObjectKeys(DATA_DESCRIPTOR, ['writable', 'value'], ['get', 'set']); // true
-isObjectKeys(DATA_DESCRIPTOR, ['writable', 'value']); // true
-isObjectKeys(DATA_DESCRIPTOR, 'writable', 'value'); // true
-isObjectKeys(DATA_DESCRIPTOR, ['get', 'set']); // false
-isObjectKeys(DATA_DESCRIPTOR, 'get', 'set'); // false
-
-```
-
-----
-
-### isPrimitive
-
-Use `isPrimitive()` or `is.primitive()` to check if **any** `value` is the [`Primitive`](#primitive) type from a `type` of the [`Primitives`](#primitives) type.
-
-```typescript
-const isPrimitive: IsPrimitive = <T extends Primitive>(
-  value: any,
-  type: Primitives,
-  callback: ResultCallback = resultCallback
-): value is T => {
-  if (isStringType(type)) {
-    switch (type) {
-      case 'bigint': return isBigInt(value, callback);
-      case 'boolean': return isBooleanType(value, callback);
-      case 'number': return isNumberType(value, callback);
-      case 'null': return isNull(value, callback);
-      case 'string': return isStringType(value, callback);
-      case 'symbol': return isSymbol(value, callback);
-      case 'undefined': return isUndefined(value, callback);
-    }
-  }
-  return false;
-};
-```
-
-**Generic type variables:**
-
-| Name                  | Default value             | Description |
-| :-------------------- | :------------------------ | :---------- |
-| `T extends Primitive` | [`Primitive`](#primitive) | Guarded with [`Primitive`](#primitive) type, `T` variable to the return type `value is T` |
-
-**Parameters:**
-
-| Name: `type`               | Description                                                               |
-| :------------------------- | :------------------------------------------------------------------------ |
-| value: `any`               | Any `value` to check if it's a `Primitive` from the `type`                |
-| type: `Primitives`         | A `string` type from the [`Primitives`](#primitives) to check the `value` |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns      | Type      | Description                                                            |
-| :----------- | :-------: | :--------------------------------------------------------------------- |
-| `value is T` | `boolean` | By default `T` variable is equal to [`Primitive`](#primitive) and the **return type** is a `boolean` as the result of its statement indicating the `value` is [`Primitive`](#primitive) |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `type` from the [`Primitives`](#primitives).
-
-**Usage:**
-
-[Example usage on playground][is-primitive]
-
-----
-
-### isString
-
-Use `isString()` or `is.string()` to check if **any** `value` is a `string` type, not instance of [`Object`][object] and [`String`][string] or `object` type and instance of [`String`][string] and [`Object`][object].
-
-```typescript
-const isString: IsString = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is string =>
-  callback(
-    typeOf(value) === 'string' &&
-    (isStringType(value) || isStringObject(value)),
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns           | Type      | Description                                                       |
-| :---------------- | :-------: | :---------------------------------------------------------------- |
-| `value is string` | `boolean` | The **return type** is a `boolean` as the result of its statement |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `string` type or [`String`][string] instance.
-
-----
-
-### isStringObject
-
-Use `isStringObject()` or `is.stringObject()` to check if **any** `value` is an `object` type and instance of [`String`][string] and [`Object`][object].
-
-```typescript
-const isStringObject: IsStringObject = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is String =>
-  callback(
-    value instanceof Object === true &&
-    value instanceof String === true &&
-    typeof value === 'object',
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns           | Type      | Description                                                   |
-| :---------------- | :-------: | :------------------------------------------------------------ |
-| `value is String` | `boolean` | The **return type** is a `boolean` as the result of its statement indicating the `value` is [`String`][string] |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a [`String`][string] instance.
-
-----
-
-### isStringType
-
-Use `isStringType()` or `is.stringType()` to check if **any** `value` is a `string` type and **not** instance of [`String`][string] and [`Object`][object].
-
-```typescript
-const isStringType: IsStringType = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is string =>
-  callback(
-    value instanceof Object === false &&
-    value instanceof String === false &&
-    typeof value === 'string',
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns           | Type        | Description                                                       |
-| :---------------- | :---------: | :---------------------------------------------------------------- |
-| `value is string` | `boolean`   | The **return type** is a `boolean` as the result of its statement |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `string` type.
-
-----
-
-### isSymbol
-
-Use `isSymbol()` or `is.symbol()` to check if **any** `value` is a `symbol` type.
-
-```typescript
-const isSymbol: IsSymbol = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is symbol =>
-  callback(typeOf(value) === 'symbol' && typeof value === 'symbol', value);
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns           | Type      | Description                                                       |
-| :---------------- | :-------: | :---------------------------------------------------------------- |
-| `value is symbol` | `boolean` | The **return type** is a `boolean` as the result of its statement |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `symbol`.
-
-**Usage:**
-
-[Example usage on playground][is-symbol] | [How to detect `symbol` type][detect-symbol]
-
-----
-
-### isType
-
-Use `isType()` or `is.type()` to check if **any** `value` is the [`Type`][type] from a `type` of the [`Types`](#types) type.
-
-```typescript
-const isType: IsType = <T extends Type>(
-  value: any,
-  type: Types<T>,
-  callback: ResultCallback = resultCallback
-): value is T => {
-  if (isStringType(type)) {
-    switch (type) {
-      // Primitives.
-      case 'bigint':
-      case 'boolean':
-      case 'number':
-      case 'null':
-      case 'string':
-      case 'symbol':
-      case 'undefined': return isPrimitive(value, type, callback);
-      // Function.
-      case 'function': return isFunction(value, callback);
-      // Object.
-      case 'object': return isObject<T>(value);
-    }
-  } else if (isNotNull(type)) {
-    return isInstance<T>(value, type, callback);
-  }
-  return false;
-};
-```
-
-**Generic type variables:**
-
-| Name             | Default value   | Description |
-| :--------------- | :-------------- | :---------- |
-| `T extends Type` | [`Type`][type]  | Guarded with [`Type`][type], `T` variable to the return type `value is T` |
-
-**Parameters:**
-
-| Name: `type`               | Description                                                                                 |
-| :------------------------- | :------------------------------------------------------------------------------------------ |
-| value: `any`               | Any `value` to check if its type is from the `type`                                         |
-| type: `Types<T>`           | A `string` or generic `Constructor<T>` type from the [`Types`](#types) to check the `value` |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns      | Type      | Description                                                                                                           |
-| :----------- | :-------: | :-------------------------------------------------------------------------------------------------------------------- |
-| `value is T` | `boolean` | By default `T` variable is equal to [`Type`][type], but the detected [`class`][ts-classes] changes it to the class name and the **return type** is a `boolean` as the result of its statement indicating the `value` is [`Type`][type] |
-
-The **return value** is a `boolean` indicating whether or not the `value` is the [`Type`][type] from a `type` of the [`Types`](#types).
-
-**Usage:**
-
-[Example usage on playground][is-type]
-
-----
-
-### isUndefined
-
-Use `isUndefined()` or `is.undefined()` to check if **any** `value` is an `undefined` type and equal to `undefined`.
-
-```typescript
-const isUndefined: IsUndefined = (
-  value: any,
-  callback: ResultCallback = resultCallback
-): value is undefined =>
-  callback(
-    typeOf(value) === 'undefined' &&
-    typeof value === 'undefined' &&
-    value === undefined,
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description          |
-| :------------------------- | :------------------- |
-| value: `any`               | Any `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns              | Type      | Description                                                       |
-| :------------------- | :-------: | :---------------------------------------------------------------- |
-| `value is undefined` | `boolean` | The **return type** is a `boolean` as the result of its statement |
-
-The **return value** is a `boolean` indicating whether or not the `value` is `undefined`.
-
-**Usage:**
-
-[Example usage on playground][is-undefined] | [How to detect `undefined` type][detect-undefined]
-
-----
-
-### isNot
-
-Object `isNot` with all **check is not** functions.
-
-```typescript
-const isNot: IsNot = {
-  boolean: isNotBoolean,
-  defined: isNotDefined,
-  function: isNotFunction,
-  null: isNotNull,
-  number: isNotNumber,
-  string: isNotString,
-  undefined: isNotUndefined
-};
-```
-
-### isNotBoolean
-
-![fix][fix]
-
-`4.1.3`: Fixes the return type `boolean`, which doesn't strictly indicate the `value` is not `boolean` or [`Boolean`][boolean] by changing the `value` type to a generic `Type` and the return type to `value is Never<AnyBoolean, Type>`.
-
-Use `isNotBoolean()` or `is.not.boolean()` to check if a generic `Type` `value` is **not** a `boolean` type and **not** an instance of a [`Boolean`][boolean].
-
-```typescript
-const isNotBoolean: IsNotBoolean = <Type>(
-  value: Type,
-  callback: ResultCallback = resultCallback
-): value is Never<AnyBoolean, Type> =>
-  callback(
-    typeOf(value) !== 'boolean' &&
-    typeof value !== 'boolean' &&
-    value instanceof Boolean === false,
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name   | Default value    | Description                                                                                      |
-| :----- | :--------------- | :----------------------------------------------------------------------------------------------- |
-| `Type` | From the `value` | A generic `Type` variable from the `value` to the return type `value is Never<AnyBoolean, Type>` |
-
-**Parameters:**
-
-| Name: `type`               | Description                                                                      |
-| :------------------------- | :------------------------------------------------------------------------------- |
-| value: `Type`              | A generic `Type` `value`, by default of type detected from the `value`, to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns                            | Type      | Description                        |
-| :--------------------------------- | :-------: | :--------------------------------- |
-| `value is Never<AnyBoolean, Type>` | `boolean` | By default `Type` variable is equal to the type detected from the `value`, but the detected type `boolean` or [`Boolean`][boolean] changes to `never` and the **return type** is a `boolean` as the result of its statement `value` is **never** of [`AnyBoolean`](#anyboolean) type but of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is not a `boolean` and [`Boolean`][boolean] instance.
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { isNotBoolean } from '@angular-package/type';
-
-const anyBoolean: any = true;
-const strictBoolean = false;
-const objectBoolean = new Boolean(strictBoolean);
-
-isNotBoolean(anyBoolean); // false; return type is `value is any`
-isNotBoolean(strictBoolean); // false; return type is `value is never`
-isNotBoolean(objectBoolean); // false; return type is `value is never`
-
-```
-
-----
-
-### isNotDefined
-
-![fix][fix]
-
-`4.1.3`: Fixes the return type `boolean`, which doesn't strictly indicate the `value` is not `defined` by changing the `value` type to a generic `Type` and the return type to `value is Undefined<Type>`.
-
-Use `isNotDefined()` or `is.not.defined()` to check if a generic `Type` `value` is an `undefined` type and is equal to `undefined`.
-
-```typescript
-const isNotDefined: IsNotDefined = <Type>(
-  value: Type,
-  callback: ResultCallback = resultCallback
-): value is Undefined<Type> =>
-  callback(
-    typeOf(value) === 'undefined' &&
-    typeof value === 'undefined' &&
-    value === undefined,
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name   | Default value    | Description |
-| :----- | :--------------- | :---------- |
-| `Type` | From the `value` | A generic `Type` variable from the `value` to the return type `value is Undefined<Type>` |
-
-**Parameters:**
-
-| Name: `type`               | Description                 |
-| :------------------------- | :-------------------------- |
-| value: `Type`              | A generic `Type` `value`, by default of type detected from the `value`, to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns                    | Type      | Description                         |
-| :------------------------- | :-------: | :---------------------------------- |
-| `value is Undefined<Type>` | `boolean` | By default `Type` variable is equal to the type detected from the `value`, but the detected type other than `undefined` changes to `never` and the **return type** is a `boolean` as the result of its statement `value` is **never** of any other type than `undefined` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is not defined, is `undefined`.
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { isNotDefined } from '@angular-package/type';
-
-const anyUndefined: any = undefined;
-const firstName = undefined;
-const surname = 'My last name ';
-
-isNotDefined(anyUndefined); // true; return type is `value is any`
-isNotDefined(firstName); // true;  return type is `value is undefined`
-isNotDefined(surname); // false; return type is `value is never`
-
-```
-
-----
-
-### isNotFunction
-
-![fix][fix]
-
-`4.1.3`: Fixes the return type `boolean`, which doesn't strictly indicate the `value` is not `function` by changing the `value` type to a generic `Type` and the return type to `value is Never<Func, Type>`.
-
-Use `isNotFunction()` or `is.not.function()` to check if a generic `Type` `value` is **not** a `function` type and **not** an instance of [`Function`](#func).
-
-```typescript
-const isNotFunction: IsNotFunction = <Type>(
-  value: Type,
-  callback: ResultCallback = resultCallback
-): value is Never<Func, Type> =>
-  callback(
-    typeOf(value) !== 'function' &&
-    typeof value !== 'function' &&
-    value instanceof Function === false,
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name   | Default value    | Description |
-| :----- | :--------------- | :---------- |
-| `Type` | From the `value` | A generic `Type` variable from the `value` to the return type `value is Never<Func, Type>` |
-
-**Parameters:**
-
-| Name: `type`               | Description                                                                      |
-| :------------------------- | :------------------------------------------------------------------------------- |
-| value: `Type`              | A generic `Type` `value`, by default of type detected from the `value`, to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns                      | Type      | Description                         |
-| :--------------------------- | :-------: | :---------------------------------- |
-| `value is Never<Func, Type>` | `boolean` | By default `Type` variable is equal to the type detected from the `value`, but the detected type `Func` changes to `never` and the **return type** is a `boolean` as the result of its statement `value` is **never** [`Func`](#func) but of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is not a `function`.
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { IsNotFunction } from '@angular-package/type';
-
-const anyFunc: any = (x: number) => x + 5;
-const myFunc: Func = (x: string) => x;
-
-isNotFunction(anyFunc); // false; return type is `value is any`
-isNotFunction(myFunc); // false; return type is `value is never`
-isNotFunction('maybe i am not a function'); // true; return type is `value is string`
-
-```
-
-----
-
-### isNotNull
-
-![fix][fix]
-
-`4.1.3`: Fixes the return type `boolean`, which doesn't strictly indicate the `value` is not `null` by changing `value` type to a generic `Type` and the return type to `value is Never<null, Type>`.
-
-Use `isNotNull()` or `is.not.null()` to check if a generic `Type` `value` is **not** a `null` type and **not** equal to `null`.
-
-```typescript
-const isNotNull: IsNotNull = <Type>(
-  value: Type,
-  callback: ResultCallback = resultCallback
-): value is Never<null, Type> =>
-  callback(typeOf(value) !== 'null' && value !== null, value);
-```
-
-**Generic type variables:**
-
-| Name   | Default value    | Description |
-| :----- | :--------------- | :---------- |
-| `Type` | From the `value` | A generic `Type` variable from the `value` to the return type `value is Never<null, Type>` |
-
-**Parameters:**
-
-| Name: `type`               | Description                 |
-| :------------------------- | :-------------------------- |
-| value: `Type`              | A generic `Type` `value`, by default of type detected from the `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns                      | Type      | Description                         |
-| :--------------------------- | :-------: | :---------------------------------- |
-| `value is Never<null, Type>` | `boolean` | By default `Type` variable is equal to the type detected from the `value`, but the detected type `null` changes to `never` and the **return type** is a `boolean` as the result of its statement `value` is **never** `null` but of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is not `null`.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isNotNull } from '@angular-package/type';
-
-const anyNull: any = null;
-const firstName = null;
-
-isNotNull(anyNull); // return type is `value is any`
-isNotNull(firstName); // return type is `value is never`
-
-```
-
-----
-
-### isNotNumber
-
-![fix][fix]
-
-`4.1.3`: Fixes the return type `boolean`, which doesn't strictly indicate the `value` is not a `number` or `Number` by changing `value` type to a generic `Type` and the return type to `value is Never<number, Type>`.
-
-Use `isNotNumber()` or `is.not.number()` to check if a generic `Type` `value` is **not** a `number` type and **not** an instance of [`Number`][number].
-
-```typescript
-const isNotNumber: IsNotNumber = <Type>(
-  value: Type,
-  callback: ResultCallback = resultCallback
-): value is Never<AnyNumber, Type> =>
-  callback(
-    typeOf(value) !== 'number' &&
-    typeof value !== 'number' &&
-    value instanceof Number === false,
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name   | Default value    | Description |
-| :----- | :--------------- | :---------- |
-| `Type` | From the `value` | A generic `Type` variable from the `value` to the return type `value is Never<AnyNumber, Type>` |
-
-**Parameters:**
-
-| Name: `type`               | Description                                                             |
-| :------------------------- | :---------------------------------------------------------------------- |
-| value: `Type`              | A generic `Type`, by default of type detected from the `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns                           | Type      | Description                         |
-| :-------------------------------- | :-------: | :---------------------------------- |
-| `value is Never<AnyNumber, Type>` | `boolean` | By default `Type` variable is equal to the type detected from the `value`, but the detected type `number` or [`Number`][number] changes to `never` and the **return type** is a `boolean` as the result of its statement `value` is **never** [`AnyNumber`](#anynumber) but of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is not a `number` and [`Number`][number] instance.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isNotNumber } from '@angular-package/type';
-
-const anyNumber: any = 'any number';
-const firstName = 'firstName';
-const age = 27;
-const objectNumber = new Number(927);
-
-isNotNumber(anyNumber); // return type is `value is any`
-isNotNumber(firstName); // return type is `value is string`
-isNotNumber(age); // return type is `value is never`
-isNotNumber(objectNumber); // return type is `value is never`
-
-```
-
-----
-
-### isNotString
-
-![fix][fix]
-
-`4.1.3`: Fixes the return type `boolean`, which doesn't strictly indicate the `value` is not a `string` or [`String`][string] by changing `value` type to a generic `Type` and the return type to `value is Never<string, Type>`.
-
-Use `isNotString()` or `is.not.string()` to check if a generic `Type` `value` is **not** a `string` type and **not** an instance of [`String`][string].
-
-```typescript
-const isNotString: IsNotString = <Type>(
-  value: Type,
-  callback: ResultCallback = resultCallback
-): value is Never<AnyString, Type> =>
-  callback(
-    typeOf(value) !== 'string' &&
-    typeof value !== 'string' &&
-    value instanceof String === false,
-    value
-  );
-```
-
-**Generic type variables:**
-
-| Name   | Default value    | Description |
-| :----- | :--------------- | :---------- |
-| `Type` | From the `value` | A generic `Type` variable from the `value` to the return type `value is Never<AnyString, Type>` |
-
-**Parameters:**
-
-| Name: `type`               | Description                                                             |
-| :------------------------- | :---------------------------------------------------------------------- |
-| value: `Type`              | A generic `Type`, by default of type detected from the `value` to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-The function returns statement `value is Never<AnyString, Type>`.
-
-| Type      | Description                         |
-| :-------: | :---------------------------------- |
-| `boolean` | By default `Type` variable is equal to the type detected from the `value`, but the detected type `string` or [`String`][string] changes to `never` and the **return type** is a `boolean` as the result of its statement `value` is **never** [`AnyString`](#anystring) but of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is not a `string` and [`String`][string] instance.
-
-**Usage:**
-
-```typescript
-// Example usage
-import { isNotString } from '@angular-package/type';
-
-const anyString: any = 'any string';
-const firstName = 'firstName';
-const age = 27;
-const objectString = new String('hold me');
-
-isNotString(anyString); // return type is `value is any`
-isNotString(firstName); // return type is `value is never`
-isNotString(age); // return type is `value is number`
-isNotString(objectString); // return type is `value is never`
-
-```
-
-----
-
-### isNotUndefined
-
-![fix][fix]
-
-`4.1.3`: Fixes the return type `boolean`, which doesn't strictly indicate the `value` is not `undefined` by changing `value` type to a generic `Type` and the return type to `value is Defined<Type>`.
-
-Use `isNotUndefined()` or `is.not.undefined()` to check if a generic `Type` `value` is **not** an `undefined` type and **not** equal to `undefined`.
-
-```typescript
-const isNotUndefined: IsNotUndefined = <Type>(
-  value: Type,
-  callback: ResultCallback = resultCallback
-): value is Defined<Type> =>
-  callback(
-    typeOf(value) !== 'undefined' &&
-    typeof value !== 'undefined' &&
-    value !== undefined,
-    value
-  );
-```
-
-**Parameters:**
-
-| Name: `type`               | Description                                                                      |
-| :------------------------- | :------------------------------------------------------------------------------- |
-| value: `Type`              | A generic `Type` `value`, by default of type detected from the `value`, to check |
-| callback: `ResultCallback` | A [`ResultCallback`][resultcallback] type function, which by default is [`resultCallback()`][callback] to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns                  | Type      | Description                        |
-| :----------------------- | :-------: | :--------------------------------- |
-| `value is Defined<Type>` | `boolean` | By default `Type` variable is equal to the type detected from the `value`, but the detected type `undefined` changes to `never` and the **return type** is a `boolean` as the result of its statement `value` is defined of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is not `undefined`.
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { is } from '@angular-package/type';
-
-interface Config {
-  a?: string;
-  b?: string;
-}
-const config: Config = {
-  a: 'x',
-  b: 'y'
-};
-
-function configFunction(value: string): string {
-  return '';
-}
-
-if (is.not.undefined(config.a)) {
-  configFunction(config.a);
-}
-
-```
-
-----
-
-## Guard
-
-### guard
-
-![update][update]
-
-`4.1.0`: Adds `objectKeys` as [`guardObjectKeys()`](#guardobjectkeys).
-
-The object contains prefixed with `guard` functions in `is` property.
-
-```typescript
-const guardIs: GuardIs = {
-  array: guardArray,
-  bigint: guardBigInt,
-  boolean: guardBoolean,
-  class: guardClass,
-  defined: guardDefined,
-  function: guardFunction,
-  instance: guardInstance,
-  key: guardKey,
-  null: guardNull,
-  number: guardNumber,
-  object: guardObject,
-  objectKey: guardObjectKey,
-  objectKeys: guardObjectKeys,
-  primitive: guardPrimitive,
-  string: guardString,
-  symbol: guardSymbol,
-  type: guardType,
-  undefined: guardUndefined
-};
-const guard: Guard = {
-  is: guardIs
-};
-
-```
-
-----
-
-### guardArray
-
-Use `guardArray()` or `guard.is.array()` to guard the `value` to be an [`Array`][array] of a generic `Type`.
-
-```typescript
-const guardArray: GuardArray = <Type>(
-  value: Array<Type>,
-  callback?: ResultCallback
-): value is Array<Type> => isArray<Type>(value, callback);
-```
-
-**Generic type variables:**
-
-| Name   | Default value    | Description |
-| :----- | :--------------- | :---------- |
-| `Type` | From the `value` | An `Array` of a `Type` variable from the `value` to the return type `value is Array<Type>` |
-
-**Parameters:**
-
-| Name: `type`                | Description                                                                               |
-| :-------------------------- | :---------------------------------------------------------------------------------------- |
-| value: `Array<Type>`        | An `Array` of a generic `Type`, by default of type detected from the `value` - to guard   |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns                | Type      | Description                                                       |
-| :--------------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Array<Type>` | `boolean` | By default `Type` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is an [`Array`][array] of `Type` detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an [`Array`][array].
-
-**Usage:**
-
-[Example usage on playground][guard-array]
-
-----
-
-### guardBigInt
-
-Use `guardBigInt()` or `guard.is.bigint()` to guard the `value` to be a `bigint`.
-
-```typescript
-const guardBigInt: GuardBigInt = (
-  value: bigint,
-  callback?: ResultCallback
-): value is bigint => isBigInt(value, callback);
-```
-
-**Parameters:**
-
-| Name: `type`                | Description                      |
-| :-------------------------- | :------------------------------- |
-| value: `bigint`             | A `bigint` type `value` to guard |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Type     | Description |
-| :------- | :---------- |
-| `bigint` | The **return value** is a `boolean` indicating whether or not the `value` is a `bigint` |
-
-----
-
-### guardBoolean
-
-Use `guardBoolean()` or `guard.is.boolean()` to guard the `value` to be any type of a boolean.
-
-```typescript
-const guardBoolean: GuardBoolean = <B extends AnyBoolean>(
-  value: B,
-  callback?: ResultCallback
-): value is B => isBoolean(value, callback);
-```
-
-**Generic type variables:**
-
-| Name                   | Default value    | Description |
-| :--------------------- | :--------------- | :---------- |
-| `B extends AnyBoolean` | From the `value` | Guarded with [`AnyBoolean`](#anyboolean), generic `B` variable from the `value` to the return type `value is B` |
-
-**Parameters:**
-
-| Name: `type`                | Description                                                                                                                       |
-| :-------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- |
-| value: `B`                  | An [`AnyBoolean`](#anyboolean) type `value`, by default of a generic `B` type detected from the `value` - to guard                |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns      | Type      | Description                                                       |
-| :----------- | :-------: | :---------------------------------------------------------------- |
-| `value is B` | `boolean` | By default `B` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is of [`AnyBoolean`](#anyboolean) type detected from the `value`  |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `boolean` type or [`Boolean`][boolean] instance.
-
-----
-
-### guardClass
-
-![update][update]
-
-`4.1.0`: Fixes the `value` is not guarded by extending generic type `Class` variable with `Function`.
-
-Use `guardClass()` or `guard.is.class()` to guard the `value` to be a generic `Class` type of [`class`][ts-classes].
-
-```typescript
-const guardClass: GuardClass = <Class extends Function>(
-  value: Class,
-  callback?: ResultCallback
-): value is Class => isClass<Class>(value, callback);
-```
-
-**Generic type variables:**
-
-| Name                     | Default value    | Description |
-| :----------------------- | :--------------- | :---------- |
-| `Class extends Function` | From the `value` | Guarded with [`Function`][ts-function], generic `Class` variable from the `value` to the return type `value is Class` |
-
-**Parameters:**
-
-| Name: `type`                | Description                                                                                                       |
-| :-------------------------- | :---------------------------------------------------------------------------------------------------------------- |
-| value: `Class`              | A [`Function`][ts-function] type `value`, by default of a generic `Class` type detected from the `value` to guard |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error]                         |
-
-**Returns:**
-
-| Returns          | Type      | Description                                                       |
-| :--------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Class` | `boolean` | By default `Class` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is a [Function][function] of type detected from the `value` |
-
-The **return value** is `boolean` indicating whether or not the `value` is a [`class`][ts-classes].
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { guardClass } from '@angular-package/type';
-
-type Func = (...param: any) => any;
-
-/**
- * typeof === 'function'
- * instanceof Function === true
- * instanceof Object === true
- */
-const FUNCTION: Func = (x: number, y: string): any => x + y;
-
-/**
- * typeof === 'function'
- * instanceof Class === false
- * instanceof Function === true
- * instanceof Object === true
- */
-class Class {
-
-  1030405027 = 'my new number';
-  5 = 'my number';
-
-  firstName = 'My name';
-  surname = 'Surname';
-
-  x = NUMBER;
-  y = STRING;
-
-  get [number](): number {
-    return this.x;
-  }
-  get [STRING](): string {
-    return this.y;
-  }
-
-  get [SYMBOL_NUMBER](): number {
-    return this.x;
-  }
-
-  get [SYMBOL_STRING](): string {
-    return this.y;
-  }
-}
-
-guardClass(FUNCTION); // false
-guardClass<Class>(FUNCTION); // type error
-
-```
-
-----
-
-### guardDefined
-
-![update][update]
-
-`4.1.0`: Fixes the `value` is not guarded by changing its type to  [`Defined<Type>`][type-defined].
-
-Use `guardDefined()` or `guard.is.defined()` to guard the `value` to be defined.
-
-```typescript
-const guardDefined: GuardDefined = <Type>(
-  value: Defined<Type>,
-  callback?: ResultCallback
-): value is Defined<Type> => isDefined(value, callback);
-```
-
-**Generic type variables:**
-
-| Name   | Default value    | Description                                                                                         |
-| :----- | :--------------- | :-------------------------------------------------------------------------------------------------- |
-| `Type` | From the `value` | Guarded with [`Defined`][type-defined], a generic `Type` variable from the `value` to the return type `value is Defined<Type>` |
-
-**Parameters:**
-
-| Name: `type`                | Description                                                                                                                       |
-| :-------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- |
-| value: `Defined<Type>`      | A generic type `value`, by default of **not** undefined type detected from the `value` to guard against `undefined`               |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns                  | Type      | Description                                                       |
-| :----------------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Defined<Type>` | `boolean` | By default `Type` variable is equal to the type detected from the `value`, but the detected type `undefined` changes to `never` and the **return type** is a `boolean` as the result of its statement indicating the `value` is of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is defined.
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { guardDefined } from '@angular-package/type';
-
-let letFirstName = 'my name';
-guardDefined(letFirstName); // true; return type `value is string`
-
-const firstName = 'my const name';
-guardDefined(firstName); // true; return type `value is string`
-```
-
-----
-
-### guardFunction
-
-Use `guardFunction()` or `guard.is.function()` to guard the `value` to be a [`Func`](#func) type.
-
-```typescript
-const guardFunction: GuardFunction = (
-  value: Func,
-  callback?: ResultCallback
-): value is Func => isFunction(value, callback);
-```
-
-**Parameters:**
-
-| Name: `type`                | Description                                                                               |
-| :-------------------------- | :---------------------------------------------------------------------------------------- |
-| value: `Func`               | A [`Func`](#func) type `value` to guard                                                   |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns         | Type      | Description                                                                                                 |
-| :-------------- | :-------: | :---------------------------------------------------------------------------------------------------------- |
-| `value is Func` | `boolean` | The **return type** is a `boolean` as the result of its statement indicating the `value` is [`Func`](#func) |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a [`Func`](#func).
-
-**Usage:**
-
-[Example usage on playground][guard-function]
-
-----
-
-### guardInstance
-
-![update][update]
-
-`4.1.0`: Fixes the `value` is not guarded by extending generic type `Obj` variable with `object`.
-
-`4.1.1`: Changes the `instance` parameter name to `constructor` cause it represents [`class`][ts-classes] or [`function`][ts-function] constructor.
-
-Use `guardInstance()` or `guard.is.instance()` to guard the `value` to be an `object` of a generic `Obj` type and an `instance` of [`Constructor`][constructor] type.
-
-```typescript
-const guardInstance: GuardInstance = <Obj extends object>(
-  value: Obj,
-  constructor: Constructor<Obj>,
-  callback?: ResultCallback
-): value is Obj => isInstance<Obj>(value, constructor, callback);
-```
-
-**Generic type variables:**
-
-| Name                 | Default value    | Description                                                                              |
-| :------------------- | :--------------- | :--------------------------------------------------------------------------------------- |
-| `Obj extends object` | From the `value` | Guarded with `object`, `Obj` variable from the `value` to the return type `value is Obj` |
-
-**Parameters:**
-
-| Name: `type`                    | Description                                                                                                                       |
-| :------------------------------ | :-------------------------------------------------------------------------------------------------------------------------------- |
-| value: `Obj`                    | An `object`, by default of a generic `Obj` type detected from the `value` to guard and to check if it's a `constructor` instance  |
-| constructor: `Constructor<Obj>` | A [`class`][ts-classes] or [`function`][ts-function] that specifies the type of the [`constructor`][constructor]                |
-| callback?: `ResultCallback`     | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns        | Type      | Description                                                       |
-| :------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Obj` | `boolean` | By default `Obj` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is an `object` of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an `instance` of a generic `Obj`.
-
-**Usage:**
-
-```typescript
-// Usage example.
-import { guardInstance } from '@angular-package/type';
-
-// Person interface.
-interface Person {
-  firstName?: string;
-  surname?: string;
-  age?: number;
-  sex?: 'male' | 'female';
-}
-
-// Class constructor.
-class Persons implements Person {
-  firstName = '';
-  surname = '';
-  age = 15;
-}
-
-// Function person constructor.
-function personFunctionConstructor(this: Person, ...args: any[]): Person {
-  if (args) {
-    this.firstName = args[0];
-    this.surname = args[1];
-    this.age = args[2];
-    this.sex = args[3];
-  }
-  return this;
-}
-
-const personInstance: Person = new (personFunctionConstructor as any)('First name', 'Sur name', 27);
-const personsInstance: Persons = new Persons();
-
-guardInstance(personInstance, personFunctionConstructor as any); // true
-guardInstance(personsInstance, Persons); // true
-
-```
-
-----
-
-### guardKey
-
-![update][update]
-
-`4.1.0`: Fixes the return type `boolean` to `value` is `Key`.
-
-Use `guardKey()` or `guard.is.key()` to guard the `value` to be one of the `string`, `number`, or `symbol`.
-
-```typescript
-const guardKey: GuardKey = (
-  value: Key,
-  callback?: ResultCallback
-): value is Key => isKey(value, callback);
-```
-
-**Parameters:**
-
-| Name: `type`                | Description                           |
-| :-------------------------- | :------------------------------------ |
-| value: `Key`                | A [`Key`][key] type `value` to guard  |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns        | Type      | Description                                                                                              |
-| :------------- | :-------: | :------------------------------------------------------------------------------------------------------- |
-| `value is Key` | `boolean` | The **return type** is a `boolean` as the result of its statement indicating the `value` is [`Key`][key] |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a [`Key`][key].
-
-----
-
-### guardNull
-
-Use `guardNull()` or `guard.is.null()` to guard the `value` to be a `null`.
-
-```typescript
-const guardNull: GuardNull = (
-  value: null,
-  callback?: ResultCallback
-): value is null => isNull(value, callback);
-```
-
-**Parameters:**
-
-| Name: `type`                | Description                    |
-| :-------------------------- | :----------------------------- |
-| value: `null`               | A `null` type `value` to guard |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns         | Type      | Description                                                                                          |
-| :-------------- | :-------: | :--------------------------------------------------------------------------------------------------- |
-| `value is null` | `boolean` | The **return type** is a `boolean` as the result of its statement indicating the `value` is a `null` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `null`.
-
-----
-
-### guardNumber
-
-Use `guardNumber()` or `guard.is.number()` to guard the `value` to be any type of a number.
-
-```typescript
-const guardNumber: GuardNumber = <N extends AnyNumber>(
-  value: N,
-  callback?: ResultCallback
-): value is N => isNumber(value, callback);
-```
-
-**Generic type variables:**
-
-| Name                   | Default value    | Description |
-| :--------------------- | :--------------- | :---------- |
-| `N extends AnyNumber`  | From the `value` | Guarded with [`AnyNumber`](#anynumber), `N` variable from the `value` to the return type `value is N` |
-
-**Parameters:**
-
-| Name: `type`                 | Description                                                                                                                       |
-| :--------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- |
-| value: `N`                   | An [`AnyNumber`](#anynumber) type `value`, by default of a generic `N` type detected from the `value` to guard                    |
-| callback?: `ResultCallback`  | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns      | Type      | Description                                                       |
-| :----------- | :-------: | :---------------------------------------------------------------- |
-| `value is N` | `boolean` | By default `N` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is of [`AnyNumber`](#anynumber) type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `number` type or [`Number`][number] object.
-
-**Usage:**
-
-[Example usage on playground][guard-number]
-
-----
-
-### guardObject
-
-![update][update]
-
-`4.1.0`: Fixes the `value` is not guarded by extending generic type `Obj` variable with `object`.
-
-Use `guardObject()` or `guard.is.object()` to guard the `value` to be an `object` of a generic `Obj` type.
-
-```typescript
-const guardObject: GuardObject = <Obj extends object>(
-  value: Obj,
-  callback?: ResultCallback
-): value is Obj => isObject<Obj>(value, callback);
-```
-
-**Generic type variables:**
-
-| Name                 | Default value    | Description                                                                              |
-| :------------------- | :--------------- | :--------------------------------------------------------------------------------------- |
-| `Obj extends object` | From the `value` | Guarded with `object`, `Obj` variable from the `value` to the return type `value is Obj` |
-
-**Parameters:**
-
-| Name: `type`                | Description                                                                                |
-| :-------------------------- | :----------------------------------------------------------------------------------------- |
-| value: `Obj`                | An `object` of a generic `Obj` type, by default of type detected from the `value` to guard |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns        | Type      | Description                                                       |
-| :------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Obj` | `boolean` | By default `Obj` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is an `object` of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an `object`.
-
-**Usage:**
-
-[Example usage on playground][guard-object]
-
-----
-
-### guardObjectKey
-
-![update][update]
-
-`4.1.0`: Fixes the `value` is not guarded by extending generic type `Obj` variable with `object`.
-
-Use `guardObjectKey()` or `guard.is.objectKey()` to guard the `value` to be an `object` of a generic `Obj` type that contains the `key`.
-
-```typescript
-const guardObjectKey: GuardObjectKey = <Obj extends object>(
-  value: Obj,
-  key: keyof Obj | (keyof Obj)[],
-  callback?: ResultCallback
-): value is Obj => isObjectKey<Obj>(value, key, callback);
-```
-
-**Generic type variables:**
-
-| Name                 | Default value    | Description                                                                              |
-| :------------------- | :--------------- | :--------------------------------------------------------------------------------------- |
-| `Obj extends object` | From the `value` | Guarded with `object`, `Obj` variable from the `value` to the return type `value is Obj` |
-
-**Parameters:**
-
-| Name: `type`                      | Description                                                                                                              |
-| :-------------------------------- | :----------------------------------------------------------------------------------------------------------------------- |
-| value: `Obj`                      | An `object` of a generic `Obj` type that contains the `key`, by default of type detected from the `value` to guard       |
-| key: `keyof Obj \| (keyof Obj)[]` | A key of `Obj` or an array of keys of `Obj` type as the name of the property that the `value` contains                   |
-| callback?: `ResultCallback`       | An optional [`ResultCallback`][resultcallback] type to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns        | Type      | Description                                                       |
-| :------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Obj` | `boolean` | By default `Obj` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is an `object` of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an `object` of a generic `Obj` containing the `key`.
-
-**Usage:**
-
-[Example usage on playground][guard-object-key]
-
-----
-
-### guardObjectKeys
-
-![new][new]
-
-Use `guardObjectKeys()` or `guard.is.objectKeys()` to guard the value to be an `object` of a generic `Type` with some of its own specified `keys`.
-The function uses [`isObjectKeys()`](#isobjectkeys) to search for the `keys` and it means:
-
-> Cause of using [`some()`][array-some] on the [rest parameter][function-rest-parameter] `...keys` each of its argument is treated as logic `or`, and cause of using [`every()`][array-every] on its array argument each of array item is treated as logic `and`.
-> Simply, in the usage section below the function finds in the object `get` and `set` or `writable` and `value`, which means the object contains `get` and `set` or `writable` and `value`.
-> The function uses [`hasOwnProperty`][hasownproperty] [`Object`][object] method to finds enumerable and non-enumerable [`Key`][key] as `string`, `number`, `symbol` unlike `Object.keys()` but it can't find accessor descriptor property unlike `in` operator, which can.
-
-```typescript
-const guardObjectKeys: GuardObjectKeys = <Obj extends object>(
-  value: Obj,
-  ...keys: (keyof Obj | Array<keyof Obj>)[]
-): value is Obj => isObjectKeys<Obj>(value, ...keys);
-```
-
-**Generic type variables:**
-
-| Name                 | Default value    | Description                                                                              |
-| :------------------- | :--------------- | :--------------------------------------------------------------------------------------- |
-| `Obj extends object` | From the `value` | Guarded with `object`, `Obj` variable from the `value` to the return type `value is Obj` |
-
-**Parameters:**
-
-| Name: `type`                          | Description                                                                                                       |
-| :------------------------------------ | :---------------------------------------------------------------------------------------------------------------- |
-| value: `Obj`                          | An object of a generic `Obj` type that contains the `keys`, by default of type detected from the `value` to guard |
-| ...keys: `keyof Obj \| (keyof Obj)[]` | A [rest parameter][function-rest-parameter] single key of `Obj` or an array of key of `Obj` type as the name of the property that the `value` contains |
-
-**Returns:**
-
-| Returns        | Type      | Description                                                       |
-| :------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Obj` | `boolean` | By default `Obj` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is an `object` of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is an `object` with some of its own specified `keys`.
-
-**Usage:**
-
-```typescript
-// Real example usage from incoming @angular-package/property.
-interface CommonDescriptor extends Pick<PropertyDescriptor, 'configurable' | 'enumerable'> {}
-interface AccessorDescriptor<Value> extends CommonDescriptor {
-  get: (() => Value) | undefined;
-  set: ((value: Value) => void) | undefined;
-}
-interface DataDescriptor<Value> extends CommonDescriptor {
-  writable: boolean;
-  value: Value;
-}
-type ThisAccessorDescriptor<Value, Obj = any> = AccessorDescriptor<Value> & ThisType<Obj>;
-
-const ACCESSOR_DESCRIPTOR: ThisAccessorDescriptor<string | undefined, ObjectOne> =  {
-  configurable: true,
-  enumerable: true,
-  get(): string | undefined {
-    return this[5];
-  },
-  set(value: string | undefined) {
-    this[5] = value;
-  }
-}
-
-const DATA_DESCRIPTOR: DataDescriptor<string> = {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: 'my value'
-}
-
-guardObjectKeys(DATA_DESCRIPTOR, ['writable', 'value'], ['get', 'set']); // type error on ['get', 'set']
-guardObjectKeys(DATA_DESCRIPTOR, ['writable', 'value']); // true
-guardObjectKeys(DATA_DESCRIPTOR, 'writable', 'value'); // true
-guardObjectKeys(DATA_DESCRIPTOR, ['get', 'set']); // type error
-guardObjectKeys(DATA_DESCRIPTOR, 'get', 'set'); // type error first on 'get' then on 'set'
-
-guardObjectKeys(ACCESSOR_DESCRIPTOR, ['writable', 'value'], ['get', 'set']); // type error on ['writable', 'value']
-guardObjectKeys(ACCESSOR_DESCRIPTOR, ['configurable', 'enumerable'], 'writable', 'value'); // type error on 'writable'
-guardObjectKeys(ACCESSOR_DESCRIPTOR, ['configurable', 'enumerable'], 'get'); // true
-guardObjectKeys(ACCESSOR_DESCRIPTOR, ['configurable', 'enumerable'], 'set'); // true
-
-```
-
-----
-
-### guardPrimitive
-
-Use `guardPrimitive()` or `guard.is.primitive()` to guard the `value` to be the [`Primitive`][primitive] from a `type` of the [`Primitives`](#primitives).
-
-```typescript
-const guardPrimitive: GuardPrimitive = <Type extends Primitive>(
-  value: Type,
-  type: Primitives,
-  callback?: ResultCallback
-): value is Type => isPrimitive<Type>(value, type, callback);
-```
-
-**Generic type variables:**
-
-| Name                     | Default value    | Description |
-| :----------------------- | :--------------- | :---------- |
-| `Type extends Primitive` | From the `value` | Guarded with [`Primitive`](#primitive) type, `Type` variable from the `value` to the return type `value is Type` |
-
-**Parameters:**
-
-| Name: `type`                | Description                                                                                                 |
-| :-------------------------- | :---------------------------------------------------------------------------------------------------------- |
-| value: `Type`               | A [`Primitive`](#primitive) type `value`, by default of a generic `Type` detected from the `value` to guard |
-| type: `Primitives`          | A `string` type from the [`Primitives`](#primitives) to check the `value`                                   |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns         | Type      | Description                                                       |
-| :-------------- | :-------: | :---------------------------------------------------------------- |
-| `value is Type` | `boolean` | By default `Type` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is of [`Primitive`][primitive] type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is the [`Primitive`][primitive] from the `type`.
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { guardPrimitive } from '@angular-package/type';
-
-// string.
-const firstName = 'firstName';
-guardPrimitive(firstName, 'string'); // true; return type `value is "firstName"`
-let letFirstName = 'firstName';
-guardPrimitive(letFirstName, 'string'); // true; return type `value is string`
-
-// number.
-const age = 5;
-guardPrimitive(age, 'number'); // true; return type `value is 5`
-let letAge = 5;
-guardPrimitive(letAge, 'number'); // true; return type `value is number`
-
-// null.
-const myNull = null;
-guardPrimitive(myNull, 'null'); // true; return type `value is null`
-
-// bigint
-const oldAge = 1n;
-guardPrimitive(oldAge, 'bigint'); // true; return type `value is 1n`
-let letOldAge = 1n;
-guardPrimitive(letOldAge, 'bigint'); // true; return type `value is bigint`
-
-// Boolean.
-const question = true;
-guardPrimitive(question, 'boolean'); // true; return type `value is true`
-let letQuestion = true;
-guardPrimitive(letQuestion, 'boolean'); // true; return type `value is true`
-
-// Undefined.
-const und = undefined;
-guardPrimitive(und, 'undefined'); // true; return type `value is undefined`
-let letUndefined ;
-guardPrimitive(letUndefined, 'undefined'); // true; return type `value is undefined`
-
-// Symbol.
-guardPrimitive(Symbol(firstName), 'symbol'); // true; return type `value is symbol`
-```
-
-[Example usage on playground][guard-primitive]
-
-----
-
-### guardString
-
-Use `guardString()` or `guard.is.string()` to guard the `value` to be string of any type.
-
-```typescript
-const guardString: GuardString = <S extends AnyString>(
-  value: S,
-  callback?: ResultCallback
-): value is S => isString(value, callback);
-```
-
-**Generic type variables:**
-
-| Name                  | Default value    | Description |
-| :-------------------- | :--------------- | :---------- |
-| `S extends AnyString` | From the `value` | Guarded with [`AnyString`](#anystring) type, `S` variable from the `value` to the return type `value is S` |
-
-**Parameters:**
-
-| Name: `type`                | Description                          |
-|---------------------------- | :----------------------------------- |
-| value: `S`                  | An [`AnyString`](#anystring) type `value`, by default of a generic `S` type detected from the `value` to guard           |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns      | Type      | Description                                                       |
-| :----------- | :-------: | :---------------------------------------------------------------- |
-| `value is S` | `boolean` | By default `S` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is of [`AnyString`](#anystring) type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `string` type or [`String`][string] instance.
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { guardString } from '@angular-package/type';
-
-let letFirstName = 'not my name';
-guardString(letFirstName); // true; return type `value is string`
-
-const firstName = 'my name';
-guardString(firstName); // true; return type `value is "my name"`
-```
-
-[Example usage on playground][guard-string]
-
-----
-
-### guardSymbol
-
-Use `guardSymbol()` or `guard.is.symbol()` to guard the `value` to be a `symbol`.
-
-```typescript
-const guardSymbol: GuardSymbol = (
-  value: symbol,
-  callback?: ResultCallback
-): value is symbol => isSymbol(value, callback);
-```
-
-**Parameters:**
-
-| Name: `type`                | Description                      |
-| :-------------------------- | :------------------------------- |
-| value: `symbol`             | A `symbol` type `value` to guard |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns           | Type      | Description                                                                                            |
-| :---------------- | :-------: | :----------------------------------------------------------------------------------------------------- |
-| `value is symbol` | `boolean` | The **return type** is a `boolean` as the result of its statement indicating the `value` is a `symbol` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `symbol`.
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { guardSymbol } from '@angular-package/type';
-
-const SYMBOL_NUMBER: unique symbol = Symbol(27);
-const SYMBOL_STRING: unique symbol = Symbol('Twenty seven');
-
-guardSymbol(SYMBOL_NUMBER); // true; return type `value is symbol`
-guardSymbol(SYMBOL_STRING); // true; return type `value is symbol`
-```
-
-----
-
-### guardType
-
-Use `guardType()` or `guard.is.type()` to guard the `value` to be the [`Type`][type] from a `type` of the [`Types`](#types).
-
-```typescript
-const guardType: GuardType = <T extends Type>(
-  value: T,
-  type: Types<T>,
-  callback?: ResultCallback
-): value is T => isType<T>(value, type, callback);
-```
-
-**Generic type variables:**
-
-| Name             | Default value    | Description |
-| :--------------- | :--------------- | :---------- |
-| `T extends Type` | From the `value` | Guarded with [`Type`][type], `T` variable from the `value` to the return type `value is T` |
-
-**Parameters:**
-
-| Name: `type`                | Description                                                                                                                       |
-| :-------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- |
-| value: `T`                  | A [`Type`][type] `value`, by default of a generic `T` type detected from the `value` to guard with the `type`                     |
-| type: `Types<T>`            | A `string` or generic [`Constructor<T>`][constructor] type from the [`Types`](#types) to check the `value`                        |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns      | Type      | Description                                                       |
-| :----------- | :-------: | :---------------------------------------------------------------- |
-| `value is T` | `boolean` | By default `T` variable is equal to the type detected from the `value` and the **return type** is a `boolean` as the result of its statement indicating the `value` is of type detected from the `value` |
-
-The **return value** is a `boolean` indicating whether or not the `value` is a `type` from the [`Types`](#types).
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { guardType } from '@angular-package/type';
-
-// Person interface.
-interface PersonData { firstName: string; }
-
-// Class.
-class Person {}
-
-// Object.
-const someone: Person = new Person();
-
-const object: PersonData = { firstName: 'firstName' };
-guardType(object, 'object'); // true; return type `value is PersonData`
-
-let letObject: PersonData = { firstName: 'firstName' };
-guardType(letObject, 'object'); // true; return type `value is PersonData`
-
-function myPerson(person: Person): Person { return person; }
-guardType(myPerson, 'function'); // true; return type `value is (person: Person) => Person`
-
-// string.
-const firstName = 'firstName';
-guardType(firstName, 'string'); // true; return type `value is "firstName"`
-let letFirstName = 'firstName';
-guardType(letFirstName, 'string'); // true; return type `value is string`
-
-// number.
-const age = 5;
-guardType(age, 'number'); // true; return type `value is 5`
-let letAge = 5;
-guardType(letAge, 'number'); // true; return type `value is number`
-
-// null.
-const myNull = null;
-guardType(myNull, 'null'); // true; return type `value is null`
-
-// bigint
-const oldAge = 1n;
-guardType(oldAge, 'bigint'); // true; return type `value is 1n`
-let letOldAge = 1n;
-guardType(letOldAge, 'bigint'); // true; return type `value is bigint`
-
-// Boolean.
-const question = true;
-guardType(question, 'boolean'); // true; return type `value is true`
-let letQuestion = true;
-guardType(letQuestion, 'boolean'); // true; return type `value is true`
-
-// Undefined.
-const und = undefined;
-guardType(und, 'undefined'); // true; return type `value is undefined`
-let letUndefined ;
-guardType(letUndefined, 'undefined'); // true; return type `value is undefined`
-
-// Symbol.
-guardType(Symbol(firstName), 'symbol'); // true; return type `value is symbol`
-
-// Instance.
-guardType(someone, Person); // true; return type `value is Person`
-```
-
-[Example usage on playground][guard-type]
-
-----
-
-### guardUndefined
-
-Use `guardUndefined()` or `guard.is.undefined()` to guard the `value` to be `undefined`.
-
-```typescript
-const guardUndefined: GuardUndefined = (
-  value: undefined,
-  callback?: ResultCallback
-): value is undefined => isUndefined(value, callback);
-```
-
-**Parameters:**
-
-| Name: `type`                | Description                          |
-| :-------------------------- | :----------------------------------- |
-| value: `undefined`          | An `undefined` type `value` to guard |
-| callback?: `ResultCallback` | An optional [`ResultCallback`][resultcallback] type function to handle the result before returns eg. to throw an [`Error`][error] |
-
-**Returns:**
-
-| Returns              | Type      | Description                                                       |
-| :------------------- | :-------: | :---------------------------------------------------------------- |
-| `value is undefined` | `boolean` | The **return type** is a `boolean` as the result of its statement |
-
-The **return value** is a `boolean` indicating whether or not the `value` is `undefined`.
-
-**Usage:**
-
-```typescript
-// Example usage.
-import { guardUndefined } from '@angular-package/type';
-
-const UNDEFINED: undefined = undefined;
-
-guardUndefined(UNDEFINED); // true; 
-guardUndefined('x'); // false; type error
-guardUndefined(5); // false; type error
-```
-
-----
-
-## Common types
-
-### AnyBoolean
-
-Represents `boolean` type or [`Boolean`][boolean] object.
-
-```typescript
-type AnyBoolean = Exclude<boolean | Boolean, true | false>;
-```
-
-### AnyNumber
-
-Represents `number` type or [`Number`][number] object.
-
-```typescript
-type AnyNumber = number | Number;
-```
-
-### AnyString
-
-Represents `string` type or [`String`][string] object.
-
-```typescript
-type AnyString = string | String;
-```
-
-### Constructor
-
-```typescript
-type Constructor<Type> = new (...args: any[]) => Type;
-```
-
-### Defined
-
-Indicate that `Type` variable is defined.
-
-```typescript
-type Defined<Type> = Never<undefined, Type>;
-```
-
-### CycleHook
-
-Angular cycle hooks method names.
-
-```typescript
-type CycleHook =
-  | 'ngAfterContentInit'
-  | 'ngAfterContentChecked'
-  | 'ngAfterViewInit'
-  | 'ngAfterViewChecked'
-  | 'ngAfterViewChecked'
-  | 'ngOnInit'
-  | 'ngOnDestroy'
-  | 'ngOnChanges';
-```
-
-### Func
-
-Function type.
-
-```typescript
-type Func = (...param: any) => any;
-```
-
-### Key
-
-Name of the `object` property.
-
-```typescript
-type Key =  number | string | symbol;
-```
-
-### Never
-
-![new][new]
-
-Choose a type to exclude. A generic `Type` is never a `Not` type.
-
-```typescript
-type Never<Not, Type> = Type extends Not ? never : Type;
-```
-
-### Primitive
-
-All [`Primitive`][primitive] types.
-
-```typescript
-type Primitive = bigint | boolean | null | number | string | symbol | undefined;
-```
-
-### Primitives
-
-All [`Primitive`](#primitive) types as `string`.
-
-```typescript
-type Primitives = 'bigint' | 'boolean' | 'null' | 'number' | 'symbol' | 'string' | 'undefined';
-```
-
-### ResultCallback
-
-```typescript
-type ResultCallback = <Obj>(result: boolean, value?: any) => boolean;
-```
-
-### Type
-
-Main types.
-
-```typescript
-type Type = Func | object | Primitive;
-```
-
-### Types
-
-Main types as `string`.
-
-```typescript
-type Types<Obj> = Constructor<Obj> | 'function' | 'object' | Primitives;
-```
-
-### Undefined
-
-![new][new]
-
-Undefined or never - treat types as `never` excluding `undefined`.
-
-```typescript
-type Undefined<Type> = Type extends undefined ? Type : never;
-```
-
-----
-
-## Experimental
-
-### BigIntObject
-
-The object handles creating and getting the [`BigInt`][bigint] with [`BigInt()`][bigintconstructor].
-
-```typescript
-class BigIntObject {
-  static set set(value: any) {
-    PrimitiveObject.bigint = BigInt(value);
-  }
-  static get get(): BigInt {
-    return PrimitiveObject.bigint;
-  }
-}
-```
-
-Create a new [`BigInt`][bigint] by assign value to the `set` property.
-
-```typescript
-BigIntObject.set = 1n;
-```
-
-Get created [`BigInt`][bigint] with the `get` property.
-
-```typescript
-const bigint: BigIntObject = BigIntObject.get;
-```
-
-----
-
-### BooleanObject
-
-The object handles creating and getting the [`Boolean`][boolean] object instance with [`Boolean()`][booleanconstructor].
-
-```typescript
-class BooleanObject {
-  /**
-   * `false` when empty, 0, null, '', false
-   * `true` when 'true', 'false', 'Su Lin whatever', [], {}, true
-   */
-  static set set(value: any) {
-    PrimitiveObject.boolean = new Boolean(value);
-  }
-  static get get(): Boolean {
-    return PrimitiveObject.boolean;
-  }
-}
-```
-
-Create a new [`Boolean`][boolean] instance by assign value to the `set` property.
-
-```typescript
-BooleanObject.set = false;
-```
-
-Get created [`Boolean`][boolean] instance with the `get` property.
-
-```typescript
-const booleanInstance: Boolean = BooleanObject.get;
-```
-
-----
-
-### NumberObject
-
-The object handles creating and getting the [`Number`][number] object instance with [`Number()`][numberconstructor].
-
-```typescript
-class NumberObject {
-  static set set(value: any) {
-    PrimitiveObject.number = new Number(value);
-  }
-  static get get(): Number {
-    return PrimitiveObject.number;
-  }
-}
-```
-
-Create a new [`Number`][number] instance by assign value to the `set` property.
-
-```typescript
-NumberObject.set = 'my number instance';
-```
-
-Get created [`Number`][number] instance with the `get` property.
-
-```typescript
-const numberInstance: Number = NumberObject.get;
-```
-
-----
-
-### PrimitiveObject
-
-The object to store static primitive objects.
-
-```typescript
-class PrimitiveObject  {
-  static bigint: BigInt;
-  static boolean: Boolean;
-  static number: Number;
-  static string: String;
-  static symbol: Symbol;
-}
-```
-
-----
-
-### StringObject
-
-The object handles creating and getting the [`String`][string] object instance with [`String()`][stringconstructor].
-
-```typescript
-class StringObject {
-  static set set(value: any) {
-    PrimitiveObject.string = new String(value);
-  }
-  static get get(): String {
-    return PrimitiveObject.string;
-  }
-}
-```
-
-Create a new [`String`][string] instance by assign value to the `set` property.
-
-```typescript
-StringObject.set = 'my string instance';
-```
-
-Get created [`String`][string] instance with the `get` property.
-
-```typescript
-const stringInstance: String = StringObject.get;
-```
-
-----
-
-### SymbolObject
-
-The object handles creating and getting the [`Symbol`][symbol] object instance with [`Symbol()`][symbolconstructor].
-
-```typescript
-class SymbolObject {
-  static set set(value: string | number | undefined) {
-    PrimitiveObject.symbol = Symbol(value);
-  }
-  static get get(): Symbol {
-    return PrimitiveObject.symbol;
-  }
-}
-```
-
-Create a new `symbol` by assigning value to the `set` property.
-
-```typescript
-SymbolObject.set = 'my symbol';
-```
-
-Get created `symbol` with the `get` property.
-
-```typescript
-const symbol: Symbol = SymbolObject.get;
-```
-
-----
-
-### isParam
-
-Method decorator to check the type and return `undefined` if it's not the same as expected.
-
-```typescript
-function isParam(...param: Array<string>): MethodDecorator {
-  return (target: Func | object, key: string | symbol, descriptor: any): any => {
-    const originalMethod = descriptor.value;
-
-    descriptor.value =  function(): void {
-      if (is.array(param) && is.defined(arguments)) {
-        param.forEach((name: string, index: number) => {
-          if (is.number(index) && index < arguments.length) {
-            if (is.defined(arguments[index])) {
-              switch (name) {
-                case 'number':
-                  if (is.number(arguments[index]) === false) {
-                    arguments[index] = undefined;
-                  }
-                  break;
-                case 'object':
-                  if (is.object(arguments[index]) === false) {
-                    arguments[index] = undefined;
-                  }
-                  break;
-                case 'string':
-                  if (is.string(arguments[index]) === false) {
-                    arguments[index] = undefined;
-                  }
-                  break;
-              }
-            }
-          }
-        });
-      }
-      const result = originalMethod.apply(this, arguments);
-      return result;
-    };
-
-    return descriptor;
-  };
-}
-```
-
-Example usage.
-
-```typescript
-// Example  usage
-import { isParam } from '@angular-package/type';
-
-const STRING: any = '!@#$%^&*()abcdefghijklmnoprstuwyz';
-const NUMBER: any = 10304050;
-
-// TestClass
-class TestClass {
-  @isParam('object', 'string', 'number')
-  public testMethod(object?: any, firstName?: any, age?: any): { object: any, firstName: any, age: any } {
-    return {object, firstName, age};
-  }
-}
-const resultTRUE = new TestClass().testMethod({firstName: 'NoName'}, STRING, NUMBER);
-const resultFALSE = new TestClass().testMethod(NUMBER, {firstName: 'NoName'}, STRING);
-
-resultTRUE === {
-  object: {firstName: 'NoName'},
-  string: '!@#$%^&*()abcdefghijklmnoprstuwyz',
-  number: 10304050
-};
-
-resultTRUE === {
-  object: undefined,
-  string: undefined,
-  number: undefined
-};
-
-```
-
-----
-
-## GIT
-
-### Commit
-
-* [AngularJS Git Commit Message Conventions][angular-commit]
-* [Karma Git Commit Msg][karma-commit]
-* [Conventional Commits][conventional-commit]
-
-### Versioning
-
-[Semantic Versioning 2.0.0][semver]
-
-**Given a version number MAJOR.MINOR.PATCH, increment the:**
-
-* MAJOR version when you make incompatible API changes,
-* MINOR version when you add functionality in a backwards-compatible manner, and
-* PATCH version when you make backwards-compatible bug fixes.
-
-Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format.
-
-**FAQ**
-How should I deal with revisions in the 0.y.z initial development phase?
->The simplest thing to do is start your initial development release at 0.1.0 and then increment the minor version for each subsequent release.
-
-How do I know when to release 1.0.0?
-
->If your software is being used in production, it should probably already be 1.0.0. If you have a stable API on which users have come to depend, you should be 1.0.0. If you’re worrying a lot about backwards compatibility, you should probably already be 1.0.0.
-
-## License
-
-MIT © angular-package ([license][license])
-
-----
-
-[skeleton]: https://github.com/angular-package/skeleton
-
-<!-- Changes -->
-[fix]: https://img.shields.io/badge/-fix-red
-[new]: https://img.shields.io/badge/-new-green
-[update]: https://img.shields.io/badge/-update-red
-
-<!-- Type package -->
-[type-npm-svg]: https://badge.fury.io/js/%40angular-package%2Ftype.svg
-[type-npm-badge]: https://badge.fury.io/js/%40angular-package%2Ftype
-
-<!-- Other packages -->
-[cd-readme-github]: https://github.com/angular-package/change-detection#readme
-[prism-readme-github]: https://github.com/angular-package/prism#readme
-[property-readme-github]: https://github.com/angular-package/property#readme
-[ui-readme-github]: https://github.com/angular-package/ui#readme
-[type-readme-github]: https://github.com/angular-package/type#readme
-[type-readme-npm]: https://www.npmjs.com/package/@angular-package/type#readme
-
-<!-- Badges -->
-[forks]: https://github.com/angular-package/type/network
-[issues]: https://github.com/angular-package/type/issues
-[license]: https://github.com/angular-package/type/blob/main/LICENSE
-[stars]: https://github.com/angular-package/type/stargazers
-
-<!-- GIT -->
-[angular-commit]: https://gist.github.com/stephenparish/9941e89d80e2bc58a153
-[conventional-commit]: https://www.conventionalcommits.org/en/v1.0.0/
-[karma-commit]: http://karma-runner.github.io/0.10/dev/git-commit-msg.html
-[semver]: http://semver.org/
-
-<!-- Types -->
-[callback]: #callback
-[constructor]: #constructor
-[type-defined]: #defined
-[type-never]: #never
-[resultcallback]: #resultcallback
-[key]: #key
-[type]: #type
-[type-undefined]: #undefined
-
-<!-- Javascript  -->
-[array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
-[array-every]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every
-[array-some]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some
-
-[classes]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes
-
-[bigint]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt
-[bigintconstructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/BigInt
-
-[boolean]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean
-[booleanconstructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/Boolean
-
-[error]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
-
-[function]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions
-[function-rest-parameter]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters
-
-[hasownproperty]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
-
-[number]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number
-[numberconstructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/Number
-
-[object]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object
-[primitive]: https://developer.mozilla.org/en-US/docs/Glossary/Primitive
-
-[string]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String
-[stringconstructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/String
-
-[symbol]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol
-[symbolconstructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/Symbol
-
-[js-undefined]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
+<!-- Prism -->
+[prism-js]: https://prismjs.com/
 
 <!-- Typescript -->
+[ts-any]: https://www.typescriptlang.org/docs/handbook/basic-types.html#any
+[ts-boolean]: https://www.typescriptlang.org/docs/handbook/basic-types.html#boolean
 [ts-classes]: https://www.typescriptlang.org/docs/handbook/2/classes.html
+[ts-enums]: https://www.typescriptlang.org/docs/handbook/enums.html
 [ts-function]: https://www.typescriptlang.org/docs/handbook/2/functions.html
-
-<!-- Playground: are -->
-[are-string]: https://www.typescriptlang.org/play?jsx=0#code/C4TwDgpgBAkgzgZWAJwJYDsDmUC8UAUAbgIYA2ArhAFxTHogCUuAfFCRdKnFHChpgG4AUKEhQACmgC2qYKkIRueAOQAjVJgzBlUAD5Q1Ae0OkIdHfuXpyU1RGQWDcELZOPlvNFnfl0AEwgAMwwIP2VhAGNDdF4oLiQvTBp4BP5cAnZKGjpGGkzObk80nFZ8uJjgOgiIQ0CoVKw9fVEaurKcDqc+b0jo2IiACwgIgGt0-BaaSVQZOQU4ABooADpV4mRMOGz6BhpVY1M6FigAbyEoKFNgKGRFclJrvBRKYQurqCkIYAHDP2TEbqCc48ADuskGBBaTDOFwuEWIcGgHkByhon2+v3S8UBAigqluxBGr1hAUCxHuwDRXx+fixAMSuPxZiJwIAvsDAoZkAQohVaBsoLV+ZtocCLrc4BT0uiafh1pgGMSLqg6vgJVKOngyaREaLYbCmYSlVB2RdTTcvuRkOgLZKHsJWb0+esIA1sHh8KtlvKtrQdnsDmYbSUoINhiN8MjEsoll6fYqhEIAPRJqAANXWqGIqlMcCEvNiCAAKgAlGAAOQA4gB9NMAQQAMgBVACi6WUDa5ECkcTAkqkAH5wvm+tdy02ALIAIRbJdrjdb6QATAB2J2xKcAeU3DZbdfL8+bba1ZER6+uTfLABEWwAxCstq+H1vVosAdU36V8pJCfmE70vG973LR9nxbYQRxiEwIGWUhDEwOVbjdfBALvB8n3rI8lmLMsqzApZx2nWd8KgLcdz3A9MNbBhFSgFMoG1RFILgaDYPgxDXUBfAcIrGsqJbbDS14sCaNxejnggZjWLghCXWQni8P4wTcL4hcBNI7dd33ETaPoxjJILaT2LkriFNUrCNPI7SlPqITFLU0S6NTfSgA
-
-<!-- Playground: detect -->
-[detect-bigint]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYewdgzgLgBAQgSQOIIHIBUBcMCGYCeMAvDAJwAM5A7AIymkBMArACxUvn01gDcMMAegEwo+AA4BTEADNiREgHIARgEsA5irBQFAKFCQQAGwkA6QyDUAKAAaIUGEeKmz5JACQBvUZJnxkadABfawBKHj1wCCNTcytbfwdNaDxgZ3h1BC1rABo-e3QYJKgUtLgMrTCIg2MzCxs7AMLIYrBU31QAVwBbJQkAJxy8xqKS9u7evsr9KJrY+oSCkda0gHklACsJYChBhsTm0dk1ze3KqpmYuutQ8OnYPfQAfTQAZXQAQVQAYQBRbDxCCQympMlBLAoKNQ6IxWOxOKQaAowoJhN40q4YMp1JptOdorU4g9nqg3p9fo4fC55DBPGjfETXh9vj9glNIvi5vF8sTScymsllvTyjtcgySUzyUs2rJgaC2dVLoSFjyJT9+S1pTBOj1+rtlYyyWqpWltRN5RcCfNuQa+cbfMctiKhhgVYb1YcYA7TuEgA
-[detect-boolean]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYewdgzgLgBAYgQQDIGUCiAuGBDMBPGAXhgDNsAbCAUwG4YB6emKPABypBKMOIHIAjECHJVcvAFChIwqgDpyIAOYAKAAaJUaZmw5cexACQBvFu07xk6AL6qAlDUngIM+UrUb0MAJaQouYLowAEJCIriqADQWmt6+-oEhMrj2jtIirirqllo+0PHmAPL8AFZUwFCR0Z65fmABhSVlUCmpzukKmXYOUtAwACoASgCqmDj4RMwATgCutAxMpoH6MAKhomASPS4daoMj2mZ6PDDGi+Z7aDYpW+1uqhexeXUJa+FRDzX5XIlhYNdO2zuHzizwapXKlWBT3qXCK4OaDlagM6-18VTQAH0AJIAORQfQQOIAwqNcARiGAqAB3YKvMDKMiUKj2eaPWow2lJMBI26ZDyY3H4wkkg5LY6nHTmfnYvEE4mXLo8uQ7LKaGVC+Vsr6c36VaWCuUiz6g7501FtZV3fWy4U5EEcuFNPXZdWGu3QwKO8otG6WlHdJywC6u21YMkTSk0n7rZRQGbMuis40c6O4JUZXbDAU2zVnI6GEySrjBg22q4BtJ+zMjEOa5MvLmQrO1o32hu-c3I6vZjWtj1gp3vZuluttgfehxAA
-[detect-function]: https://www.typescriptlang.org/play?target=7&jsx=0#code/C4TwDgpgBAYgrgOwMZQLxQBQDodgIYBOeAtgFxR4IgCUaAfBVQNwBQLSA9ggM7CwCqAOQDCAFQCSAeUHl4yNJgAe5BHGIAjCAQA0UEOV4EAlggDm1cpRD0oiqAGo9rTjw4AbCFjcdTGAAYwQmJSglCgkBwAZmio6ADkACQA3uEQUQIiEtIAvnF+utTOXNzunt6+AUFZoSa8lEhp0XJIwEZc+RnB0lC1wPWNsIgtbQjU7MWlXj7+gZkhPTx9yAOS6gBWEC0ds101i-3pqxstY0A
-[detect-instance]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYGwhgzhAEDC5WgbwFDWgD2gXmgVgG41oBPHaAAwEIABAYgBIBSAPQDIAqACgEowAjYABMApgDMA5gAsAlgCsA1iAC2AOwD2ABwBOEAC4BXAO4kAXhSIBfFMHWqI6kCIB0IdRK4V4kGHpKaRdTEcbFwGJD8AoLgECEsKHiJbe0cXNw8vWOgZez0wVWBA4O8oCgAaGJ9s3PzC6JKIRJs7BydXd08G6v1aougAMQMCvRk7csrEHJ6CvsHh0dUm5Na0jsyqqbyZ6IB5fjkRYD1xrs3e3f3DvSbmlLb0zwSklr04ABkAQQBlL4B9AEkAHJfAAqH0BsAAogAuaD5Mi4VQiIwTCC8AjQAD0mOgkT6oVwAHJ1JcjoTbit2hlYJ8fgDgWCIZDcf58aFoOE8fVaX8gaDwVD4ksWqkqZ0efT+Uzuls6sVYicJXzGVCZed5T5hXdVtSlQyBcyzttgnMjgtFd9efrpUa5QMhma7FrKQ8vHqparbX09gcjha6cqDWrjdAfVcmkA
-[detect-null]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYewdgzgLgBAcgVQDJIFwwIZgJ4wLwxgCuANiQNwBQokIJApgHQkgDmAFAAaIoxTYAHeiABm+PAQDkAEgDe-IaPjIkAX0mcANDACUVGhDpMWHbipgBLSFCzBhYgGJEwwKBfBblvK9Fv2YTi5u4HrU4IYMzGxcPEiW1n5KcEQAtgBG9ABOnrHxvi7+yelZoQZGUaa5PjYFSgDyaQBW9K455tWJYg3NrqXh5SYx7Qm1Yslkbd4jdkoAylCZVqyhQA
-[detect-number]: https://www.typescriptlang.org/play?target=7&jsx=0&ssl=16&ssc=46&pln=16&pc=75#code/AQYw9gdgzgLsByBVAsgIQKICUBcwCGEAnsALzACMADAMyUAslArJQNwBQ40YANgKYB03MAHMAFAAMkaLMBiEADrzAAzUiTIByACQBvOYpUIUGTAF8N4gJTtOUHgKFjJxmQEtoMAiCWqAYgFcIEBhXSHEAGiNpTGB3WC8fYACgkMhrDkg7PkERCSkTWI8Ew3h-AFsAI14AJwiogrjPIMTSypr023scp3y3IubDAHkKgCteYLremMbi1WGx4OtgNgyubMcJKxtMuCmAfQBJeABlABUAQXgAYXRcAmIyVqrq0SpaBmYOzK6N52jDk4Xa7oWQKRLqTS6fQtFyYAFnS43cxbVZZBy5P4meFAm6FeIDPyBYKhCCTWHYxEgmYEpJE1IQL5rdE9clHBHAvFNbwlcrPMn-Nk4qn9bmqJ7tbZM7p5VmAymc2bAebjGD8rGC+XU0VK0Yq9Kon4YlG2Xbk+DoADqFOBdyIpGAEF4AHcELyaq8aPQmJRGWjpZisHtzVaNRzoYYIcBtHowSUzZbrUiLL7DSz-sHE8L8drksSwpF9hnQ7itYlc-SU+sMYWE8Ws1yWm7agX4yG5RzSzy2tVK8yZena+2SyLEsqJi2B232cPs6PdYt2EA
-[detect-object]: https://www.typescriptlang.org/play?target=7&jsx=0#code/JYOwLgpgTgZghgYwgAgPICMBWEFlSFAb2QA8AuZEAVwFt1oBuZAXwChRJZEUNtcAVAO4B7ZMXLIAzmCigA5kwCeFanUYtWrBMJDS0AIQBSAUQDC-APqoAcsYq8ceAsgC8Y0hQDMABl8sGWjqSwgA2EAB0IcJyABQABqhGZpY2xshgigAOEMIwri5uAOQAJIQZ2bkGJuZWtsyFcQCUAdq6oRFRsQlJNanIoNJwIEiV+sLtQ3EANFXJtWkDYEMjeWMTIM2BbWGR0fGJ1Sm2-bpLwzl5AGJUw2DAOtOzvceLyxfI17f3Gy1B7btdA5zPqvc6Vay0ehQR5A54LU5vcGQ6CbVrBHadfY9I7wwZgvIOXAw7HzE54lZoLCOZrILbojp7bqHUmgikAZRk8mJzJBCPxyA5shAclRfwxjNhOLJZ3ZijooW5wJefNl8pCmzp-0xcSav1OT0s-AA6qh7FSBCJXO4JIV8CghKJ+AALKAQCCFGbKZAARl8fn8mvFgJJxtQ6Sy7wKRVK5XekosofqusDDODzND0sRq3GYUmM3jGdZ7zWuZ+KYBWPTJsz-M+uG+ipqhZV7zrdx0ou2qcrc2b5PeELU0PzIerRaRQ879IrTN7Y5blUJYEbhvn-cX5rANPL2oLa5l70FXJHVbD47yR+FU61EtHZ4XF7l6AVJ7n9-Xj7VGrRN66ybRYAGvMFi2EaVoEIIlJ8GAMTxqk15BvEbIAJoALL6KgAAyIEAKrocYABK4YVHkUbICUZQRouJKpCBxhGkmCHdrOcJ0WB57ICWEB5kBtGgTWFJcUMTEznBthsQJrY3PWDyvqx-EcW23wibuNHiQpD7IIOUIrsBGkflpyJQCpt48up9GSRu0G6XxFkcUu24-ohLE4hJHGXnINnmexmkeSZaZKsYbm+U+L68d5lmfs+6oBDujL-kEgF7qgEluBBUGOLBd7+T2TYmhJsaVGRFGFQSd5sYxerTqpp7BQZQkgLpoZ1Qeow5txZZOcxyUtVmHzSe2jVyauKX6a1VwDcpVW-rlI29fy2nQE1+VjX1i3GdNzk9at-JLsto12ZpDlMHFAV5QdPkGR5+3zeynJXpt3XlTtqrRTdL2HqFMWaEAA
-[detect-string]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYewdgzgLgBAygFQEoEkByBxAXDAhmATxgF4YByAQgAEBiAEgFIA9AMgCoAKASlwCNgAJgFMAZgHMAFgEsAVgGsANgFswIAA4AnaAFcA7gQBeZANwAoUJBAKhAOgUgxHAAaJUmGFAJqhIESWKkZHQA3p7evvDI6BgAvmROXGYWEFa29o4uUe5SkFD4wD5+AGLaYMBQUuBOADSRbhgwOdD5hTAlZRXgiebgKdZ2Ds6u0Y25LREA8rwyQuU1dSNNeWWtUzPliTA9lv3pQ1kNS+N+cFAaOWLzw9ljKxGn52Bi3dt9aYNOCUm9sNcYAProRAAQTQAGEAKI4fBEUgPC4cP7dZKpAYZP6AtAg8EQjxeVoBQIhMKtDFAhCgyFxL6vVF7TL1THYyGjZp3YqlcqVMBXA5Mik41nLAoRdpcrrfHbvdF88mU3FHdkwNazKC8xlywWKkV+FUbSVvNH7DVYgUs7Wks4XdXRfnyoXHeBWp4vFG7D405K-PloCEAdTtOOhhBIMDAQl0TsejiRBrpHwxvoDmpZJIihPIxPx9x9-sDVPiyN68ZljKT+YVtx1bU5nR5tUTeZTlbZ1bFdaLUqNDNt5ebDqVerVDdzydN9otk2mqs7hvpjbHzJbwst0ZtmH+ffHWqrq4u3SAA
-[detect-symbol]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYewdgzgLgBAcgVQLICECiAlAXDAhmATxgF4YBGABgGYKAWCgVgoG4AoUSWAZQE1UB5ADIB9RKkw58RUlwIBbAEYgANgAox6DAEo2HCCoCmAOmUgA5qoAGvASI2YYUAgAcDIAGYlipAOQASAG8nVw8YGxQhUWRNAF8fSx12cH1lY1MLaz4Iu2iHAEtOfGA3TxQQQ3xLABowrMj7DBgC6CKSmDKKsES9QxNzK3D63MbmqFbQgDEAVzBgKDzwatrbKPERwtm26dn58G7k3vSBupy1po3i0LgpxQMAJyXB081zls2rm4V7-chD-syVg1XmN3p5+AoAFYGOaPE6rF6jcZgyHQqA6GBJX6pPoZJ7w-IXNpcKB3ApmWGA4bApFhElkn4pNL-PFAxGgsLyJTKCnZfHrN6XTyyRQqRKYxk4qwJXTJbgAFQwAEk4ABxSSEEgwHwAQgAAgBiPwAUgAegAyABUqi0uAUwAAJgZ3GYABZ5CEAa2UcjAIGcd2gUwA7gQAF4+GWcZa8rgK5VqvAamSclSqWNK1UMv64uHp+OOFxtby+QLBIm5uOquLS8XZ44rPOq6nsjqpSo1PGNlXNwXtcptrqRiVHAExyvdtm97ZzBZgHmRLs9rYzGd7Id10cL8dLj63B4disZieE3dfO5Z7EjzvbydtcFQmEHhs3k-Ih9o9eX5mH-O30LE0kwHJJ8xyPHchTpICLyZHNnzAv8hRTbkQK3eDXw5EVlESIA
-[detect-undefined]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYewdgzgLgBAqgOQCIFEBiBJBKkC4YCGYAnjALwwCuYAJgKYBmAlmHTQNwBQokIANnQB0fEAHMAFAANEqTNiQwoxAA50QDcmQoByACQBvJavXxk6LDgC+2yQEouPCPyEiJ0s3JwwW0IsDUaaNTAUEzgkgA0prIWCj5QfgEwQWAhYWD23OBOAsJiUjLm8t6QCalJCJQAtgBGdABOkdFFXvGJJpW1DZmOznluhZ5xpe0aAPI1AFZ0IU2DsSW+5SYT0yH2MFm8ua4FHgttyxoAylD1LKJz+8WH-ian52CimVs5LvmSdlwCsGAgUEhGCw2PgiMQHNk+rtJH8AUDWDRFCoklodAYjElYYDmAjrF9XlCPlj4WxFmU7oFgqFwlFiTjSbckik0uAepCdkT-tjgYjGR1qnVGrSuSTeSMjjBOoK2dt3m46TyyaMYKsZlAmgqEUqJar1hDZf0pJqGeKKTAHhcNSL6WKlmaLU9MkA
-
-<!-- Function: is -->
-[is-array]: https://www.typescriptlang.org/play?jsx=0#code/MYewdgzgLgBFCeAHApgeQGYwLwwBQDcBDAGwFdkAuGQseASiugCcBLMAc2wD4ZUAjAFbJgUAHSImIKFKTJR0gMpRWHUcBLECJcnVERiLYMlwAOADQwAtAEZd0gDIgA7siYBhQhGN0A3ACgEFBgABVYAWxYoFnxkbBg+EBBiZBoYAB94lnY2WAywUmJidJh8sL5XYuY2TgyIeDKk4tIwABNkdDZkFv9A2IBJCABBJiZCeDitMkpqWjpuGCIpmBYIGGHR+AAeGnguf1BIWBX1saoBk-GcTYAVWS5J8iodhgXtWJW1kbGbu+4-GDgsgwD2Qcyw4JgAHJCF94JCYAAyBH-T4bUTHWEgsEQ5TkRHIgGLPFsaA0IwgTAXbA4ph4pEo3oU15LcE4SEgQTCKCQ-bgaAwBTXABKfQAcgBxOKQxxMZBhZaICCkMIAfh5fgO-NFAFUALIAIQAokK4gAmADsvMOMH1qFQ9kNg1FcXQJC8Vv52tFABFDQAxMWG71xZptDpgLoe2CDIVCwYATUFIolVAumyqHB4OAA2tDIRZIXx81DgJCALpRtaxhM6g3G1OwzalcpMLMwbPWCymiwAZgrGr50er8eCIt1fWufQAaoaGxtNqEWBEojE29moRn2MWLRZcbF+5rYAApBSoUUAfSng3s2sNcQA3uhElRrKaewBfD1JOTEEDsXAAAZJmK4oARYGIbLgwESnQvgwAA9PBMCusQXgDpA36iL+-4AbWRpCmByxDJieHGrBPgIUhKFeDA6EQJh2GAba9qOqKhEQWMuDMQ6TrkZRyFusgdEMX+gFer6AaikG7HEZB4n+oG3p8YhAmoUJmoiThMZxomwogTJFy4NpCbQeKylIXuwnJFhokAcZ8akQR4GyZx9mOeZcC0upfKaYB9mjn046TjOBmYv5Y4TtOhoeZZGnWYxAEnmel7XreoWQUlF5Xje0VwSp1FCUAA
-[is-bigint]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYewdgzgLgBFCeAHApgeQGYwLwwBQDcBDAGwFdkAuGQseASiugCcBLMAc2wD4ZUAjAFbJgUAHSImIKFKTJR0gMpRWHUcBLECJcnVERiLYMlwAOADQwAtAEZd0gDIgA7siYBhQhGN0A3ACgEFBgASQgAIRZ2YLBYHC0ySmpaOm4YIgSYFggYPki2KH9QSFgsiKiYqlCy6Ni8dPIqGnoqeuRM7Nz2fO4-GDhZDHidbCwcAHJO-LGYADIZ3v6UEExWkfHJmLHC8GgYBQAVACVggDkAcWwYMccmZABbTMQIUjuAfi2-It2TgFUAWTCAFFDpcAEwAdm2xRgYVQqHsgIAgidLugSF4obswsEzqd9pcAJwABiJ4OsBIJoIArAAWcE0okU6xgTEgYhyYggdi4AAGB2O5x5FlKkRquH5pzOdF8MAA9LKYGjiF5Pjs2RyubzfgDgUL2tUYrhtUDDtKfHKFUqVV91aJOdyebD4UiTnqReUoLgnQjkWaLYr0chVZBbfbedjcSd9m7wqLDRG8X75XAmOQ-EA
-[is-boolean]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYewdgzgLgBFCeAHApgeQGYwLwwBQDcBDAGwFdkAuGQseASiugCcBLMAc2wD4ZUAjAFbJgUAHSImIKFKTJR0gMpRWHUcBLECJcnVERiLYMlwAOADQwAtAEZd0gDIgA7siYBhQhGN0A3ACgEFBgASQgAIRAQYmQabDwiMkpqWjpuGATyGBYIGD5I6Jp-UEhYbIiomLAqUPKCsDitRKoaeioM5CycvIrYrC4-GDhZDEadbCwcAHJuusmYADJ5gbxlwdxVwaGUEEx28amQQWEoOcWNwb22aBojHZhayv24Jkyzzc3LkpvkO-4hESeynIGzoGwAPmCNut3hdtB0rlBvncHr0JjB0CQvAsljD0nCsl8wLdMH9jk8McQsW8YYEfrt8RMpjNKqccTDRh1Gc9MhC8YlyZjkKD3sKYL4-MVoDAFAAVABKwQAcgBxOKTRxMZAAWyyiAgpC1AH5JkVwFLFQBVACyYQAonK4gAmADsppK91QqHstoAgoq4hSvG6pWFPd6-QB9eUW21xIHIYOwUNe32KiNK2V+tyxnBgZBOe75Sq4QNC4MVUTEEDsXAAA1lCpVtYsZSLNFwDaVyrovhgAHo++jBRKzRWqzXa5abfbm50UWBcFO7XKez5+4PSyPIGPq3Xk+HFbPWz0F-vU6v19zkFuIDuJ2fI9HbUfwm3T2HU1G5TGLwOrze7z3D9IwzGUs2fFtXxPXAHzTUDwN-Qd4z8IA
-[is-function]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYewdgzgLgBFCeAHApgeQGYwLwwBQDcBDAGwFdkAuGQseASiugCcBLMAc2wD4ZUAjAFbJgUAHSImIKFKTJR0gMpRWHUcBLECJcnVERiLYMlwAOADQwAtAEZd0gDIgA7siYBhQhGN0A3ACgEFBgAMVIwYGw8UWjEQiZCAFsqGnpualp-QOQYAEkIUPCoFnBIrTJKdNSsHiJymBYIELDgf2BiT0a3dohGgG8YAA9IgFYfGABfP1BIWAaCkWKwKjz5opKcMvJk2gYYWvJ6xvm0rIxN5DpsLBwAcnRmtbAbmAAyF7hZEEx97Ovb+8Ki2ebz22mybGgNCMXyagPW1zgTAOIJ+9RmUOQMP4QhEVxwynIrXA0BgACFUKh7ABRACCADlIgTkESZmScgBxHJ0gAqkQAnAAGAUAdmsfL5ACZhgAWYXSgXi6xgFkkukAVQAsqSqQAlSLWCXClWwBTcnVc9mRG4a+AwMCkBJ8VyHG7GkJquluKjHDYDKj2x2uXYpNL9JjIKCkJhgQYwADUMFGEymxNgXNN9LcVMiYGQThgXQ6uF8KcgIGIcmIIHYuAABoWerWLHMHotcA2IHRfDAAPQ9xHkUsQcuV6u4G6kjlc7k3Zv5VvgXCTzk8rtjPswdAkLxDkeiKs1icU6n02eHVZt8mU2l0te9-tb4g76bDiv7sc3dVa3VnltwsC4F+2o6neG6Ps+xJ7ge46muadLsr+87-rgsEWqBD7bsgu5vtBtbBB6bhNueC4AfhnroQOWEvlBH7ptymZUohF6LnRDEUeBVGQThY61sWaTDERf4LIufHVImFFMkAA
-[is-instance]: https://www.typescriptlang.org/play?target=7&jsx=0&module=6#code/PTAEBUE8AcFMDoBQAXGtQGED2A7AzsgE4CuAxsloQDxRwB8oAvKDrAO6gAU8PAhoQHM8ALlC8ckANoBdAJRMGtWAG4UaUAEk8AMWI5yAS1xMuAN14AbYrFHjI8xg3NX0BvFx7xo-XgFtbEg4MdqqocJp4GvjI4qTozFQA8gBGAFZ0nM7WAZAANKAG0bE2mLgEJOSUSWl0QaBZru4pqaHqWgDKRIUCJpmW2WKBCvX9jaDl3a3hWs2w5CbV6X0uOfkA1rCQAPyiEzgCdQ0FTWmqIKC6+shGOEikZcigYbCJAGa9DTmyu137w7PkLyELAUZ7wCidQjdeCkSwWZbWWTwPAWAxxTgADnyAFoAIxIigAGSwbFghAwvDwsE4slU92ix0uhlwoi0TOuxmYCJKdm+Ixcxw8PG8hD8X2GdmGzze3IcjGYAHJXnpmTgFaAAGQap5oLDvI7yxXKq43dVa-nWApFfSwPUXFUcnBMeVPEjoc1HQoEYp2gGPQ2u6x0h7HSHdVl4MN-LmfQb2USe9x7HqOLjPO0Gl0KrBpObIM3az3WuK+3PzD2jK3em12qMHUAAHwbOrgGcrAYVyYVwYZbj9Eb9C2aJhzqTzGVjdnWmx241+BwTlbcoGHjkQoDTaBlDTlitHeYLLdt+vbWf35EPRerJfeg4DRER643oC2ofnnA29ifz5foE-VotWBv1AUQHyAjdRFeSwqR7Ahjiia8Si0BCYhtIcam5VYq1QuJRGwaIKgoahmlqRcBWXVc6CfPsy2QRYJ1GeQtmAtx2RuTgvRw2AmOAjcry4u1OOKZ1mDAzVtTcOsOOLBBoGBUE0BhB5CMoeAcD8bjgMg6DwJA0AoIsGDEEQUgLEpdx2iwXxYAwMy8HcABvUAAA8TFxAAmAB2ZRQAAX1AUzzIgNgsFsoKnMgEwFWJQhYF8ApoDwYhfG7PzjPOAA1fgDF4ZILFgPATJDdpwAAJQ0AA5ABxAB9DKAEFCQAVQAUSimK4oSpLfC2VL6TgiqmoAWQAIRa0q6sa1qTC8nz+seEbEkSQkWvqirJuatrmAMmCApDJqKoAERa7RKpaw6NtamrwAAdUSEw9AAE1gV5ClgR7VHyx4DuO06KvOy6Wtgx52kSIaWowQl6vadoTFYDhLOssL7JpOaQ1uxJIeh2HmHh4LQrsvBUeM-qsHy+ALCwAQOMiGSqERmzCYyDGsZh-IGeRvBZFpUBzh2oDSfJynqbcFDinpqzGfMjJQfB1n2nZyXOe5nzzjAor8DJhBhZpsWbQlpGmc4FmobZ-HlZ5tW3UQIA
-[is-null]: https://www.typescriptlang.org/play?target=7&jsx=0&ssl=11&ssc=21&pln=11&pc=33#code/C4TwDgpgBAkgzgOQK4BsVQLxQBQDcCGKSEAXFPgHYgCUmAfFAUdAJZxQWooDcAUAMYB7CnGBRQkAPIAzTDibEylGmVEAnFhQDm9KJIBGAKwj9gAOjBrBwa+AhmbAZWAbtZ-oRR5CxambgoLPwQ2AAcADRQALQAjH42ADKCAO4QagDC+HAh1HxCImJsyGhk8MXoWN7MSlTUZAqs7JxouhIQMlW+mBhYAOTNKL1QAGTD4naCsg3dfYJGJsBDo4w+0D1YA3nColCOACoASjAIAOJyvUlqEAC2UCxgcEjXAPy9WwVQCACqCQlymwJtmJvgBZABCAFEDnIAEwAdneOzBkkkCQhAEEEHJpIRsoixMjURiEAB9Q5fCFyFzEfFQQlozEk477THpSkbCDJOmCQQoCCUbA4lDZXKAkS8+woQRabAAA32R1OssiRS42AVxxO1FyUAA9LqoELsmK4BKzFKZbLvr9lXdEGrrQltdw9QbqRATWaLXLQZCDrbVWhsL6oc7XYbcR78qa+ebpXL6cSA-ag4nMWH9RHhVHtl747K06TyRDk+VsIWyQcKRmDUac+LY96CyiGaTmXtWSWVSmvBX252a1njUA
-[is-number]: https://www.typescriptlang.org/play?target=7&jsx=0#code/C4TwDgpgBAkgzgOQK4FsBGEBOUC8UAUAbgIYA2SEAXFMQHYgCUuAfFCedAJZxS2oaYA3ACgAxgHtacYFFCQA8gDNcBdhWp1G1aZk60A5iyjy0AKwijgAOjCZxwe+AhWHAZWC6DV0WVJEyFAxWcKScohD4ABwANFAAtACMQQ4AMuIA7lgAwsRwEQwiElIy3MjoWNTwZQIq-hwa9AzUalw8fOXYOMzCULJOSnWBuDh4AOTtAqNQAGTTPQTzvdwAYnqcwBEtTCN4HhQzc729+ItHLVB60nTh4srVWMN4imR5B6e955fA1xC3xmYWGQ7KDPUivWbvPqQP7nYHjfhYUanBinAA+qNOJyORzkv2UsJGUFG4gBlimEOxHwCXGKPz+906hL20AplM+tNoN2UJnMlkeskwFGR8wKYkk0igACEYABxGAIAAqKgAnAAGVUAdgSyuVACYAKwAFg1htVOoStEK4pkkvk8hSAFEAIIIFSgvJW4pQBAAVQAspKHQAlFS6jWeiW+gPBgD68tcCpdWQdKloEHS3oRmHw+tFRQlCaD8plKlGaUwEBQFzAcFQAH5RhHxKRnKRxPp8AADaVyxWd2KlLP4HvyhUMApQAD0k5BLwgYqkzdb7a7tvtzoQ-YuiCHa8dLvHginM-d8-zS6sbY7najgaDW8HHXwt+Dh+PAqF55bl5XN-9d7jBAEyTB0Hx3J8XyDQDgIQZM32nD8z3FC8ry7QtizAhl8HQhAZXgk852EYQgA
-[is-object]: https://www.typescriptlang.org/play?noUncheckedIndexedAccess=true&target=7&jsx=0#code/JYOwLgpgTgZghgYwgAgPICMBWEFgJLjTxLIDeyAHgFzIgCuAtutANzIC+AUKJLIiqjAALaBmy4yyAOY16TVh05gAngAcUAMTogEyALzIAFADpTquFDgMacEMoCU+gHzJbylkrUo8AZzE4wfWQAHjEnQwA3OAAbOggbOwAaZABrCGUAfhofMChQKUc9FyjYlGAfNCwPFXVkXwA5AHswerpo6KDImLiabRSQRoB3EEKXdEbG6IhbDwRGkBzkcqaWtuiaBubW9s6SnuQ+geH7GnHJ6ZBnTmRkGohUGC7SxwBCPQMAcnp2j+QAMj+12QexQbwM32is3mizuD123XirjsJ2QOTyICkzkq4jAxlUUGazS8xjAjQAyrl8sYEDFok84vZjD5osAkIYABzJAC0AEZGaSADJDaAAYTgPgghnsUIWgXKFPRmIM9MRbhRIKWFTR+Sxd0aMGBCP072QH21GI+MsW5X8uA2fiwASCoSw4RBCWUyTSmWylIx6qN5WxVxusMeIMKJo+jUduF+AKBeoNGvenxjOPjgJuGtAOVsSH12KdqduUDiQJuGU1Cvyhm9kYMuXLNxbyCr3qWlxTJqbKABRg14uxjKE4tQwwACgT1FAVHX0g3S82WzRe0CaPBohKPEDOAhouKKiLoU3cI0oCKDz4KuQKEEAKxsLhzWXIEWoepkgAqACUAKoil+qA-gA+iKAoAIJkmSQQgBAgxvieZZnheV4+FKVqBAAUmSH4gagABCWEAKKATQtr4IQfAkAYt40AAzIoL6LBof71CKNBaDonTULQjDMFAKJuFiFCYcgBGoKgArERB9RBL2O7MecxjRI0UiGAABsesrIaSqGHhpyQ2rGYDBNpaJ0Chl6HuE76fr+AFAaB4FQWS9jSsgAD0nlLhAe7QspqnqRpOF4YRJGAYZmoUaEwiiCZ4ShfU+FEaRX7uWw3m+f5CyBWpmmsexUXGTiwRcQg4SFSKGVeT5m4SjlPh5cFdnfv+gHAWBkHQQA2hQAC6xUOqV5mnnp1nXrZH5tY5nUudByQfBQHw1Vla5KVMKn5SFuHJeFaU9cog1GcNASxSIUAUYlu0pRFX6LcoK0eVl9V+RtEBbcFVV9cd0UmWV2gVYYVWLctq11TEDXvZ9mkSVJMn1ENMVuOEcPSbJ4PIK9nBAA
-[is-primitive]: https://www.typescriptlang.org/play?target=7&jsx=0#code/C4TwDgpgBACgTgSwLYOAgbhAzlAvFAcgCMEBzBAO2AKgB9CiB7RgGwgEMKb6CKBXJEQhxuhLCEGtRBLMEQVS0vhQAmEAGaUIKggG4AUPtCQoASSwAhZm054oACnTsWfCAC4onEAEo8APignF2gEHCZWDgoDY2hzADkBITg7R2dXDy9fXACg1yhQqH5BYWjwWKx4ZFQMaHwAHgAVMr9U4IyKEAAaKBiPSpQ0TCwsnLSQnCbIUpNzAGU5SlIU3PdPDpHAsfycWXlSafLZiSYWZbH2n39N4O2ocUkWA7MsAFVVDS0VM7a1y+zrvIFZRqTQUbQGfQAY0YFFk2wsZFMVG+6V+3g8K1uJHIyP+MUY6gBtVw+GIZEo1AM0NhwHh1kiHnMVgitnwrVRmQxWwK4RsFCu7JCNM4kIgBKgzL5UAAZNKiflhRRReKAPJEABWEEhwF8tHo9kFeBJPTgeT18pJ+HUziwEF8sp6ZXFmMtDHpnAI3ipMLhoQSxTgjKw-qSKNWnPlBSKobxTsJLuNvESwhoAH5tgAxSioCCC3xcm6UWQisWEkPCGVyzFF4Al1UarXAb007bzPZBtuLMMXdGRnYLBQC-HxraugiMBvamgO6uK5WEtWa7WVyNz0tQTsKXX0YcWxO7RZ6KE+2mhI4PDvHVjdtEFwE7K+nWOQZ2j-ePo-U32vd6g7RBt4QU+G8I2rHBgQ+MEvn+BN8Agv8vgdXdYMIeDPiPY8W1CfpqkwIMcMGWooEaZpBQubpelgRABhqYY73GKBJlqAIAG99CgfJCXsM8B1IewYm8Xw2I4jisAAd1QSEAAsHAEqBhJEjjIXYW0GHJKgCA8OAIGAPg4H5UIEVIJFgDzAxFKUlToGId0uC0nS9IMyxbLM9iLOU1SkwDTSoG03T9O2cs4FciyoA86yDwUHy-Mc1teJC9yrLED97P8pzzxOBLFPC1Df3Q1LYtCQDIO0LKoAAXzcyqOJigLrRYW0DHKiEv1pCwVRVAAZABRABBOI7HqxrMLhCxTAAcVMOIGjsABOAAGeaAHYAEZZtmgAmABWAAWJadvm9aVqiEbaTiF4AFkLG6gAlOwVo2pbmzhWYGhuqbxrsAgLpAQpk2SUJPxPKAXjiAARbqMym7qwbsNCoOe2lZgATSurq7Ay1h7AIeHtE9Z6IgAOhYRg+IAAzGybprJ7psOo3CIDqbEKRaSmpoaboyRxahBN0KAAHp+ZNVwRqJknyfarq+riGntgImo6ki0hWY6nr+s53lIk9L0BaFuQRa-MXSfsMnzqu27ZbpqpCLqaNhBaM3rpuzm7ZEXndeFiBRbYYnjbJ173ricbLYqembaVloA4+zmle1vnBc972IF98mUbRzqQ-lzBFcfSPUfazqY4-d2E-1r3DZ98WTdBiGobiGHM7DhXcZUFoa8h6Gwc5lu449svDAr5Oq9Ny6ncb62FeZqgHdH26NfUnmdYToby59I3ycdi3adDifs4j+xN+dsReN75ebVX2F15NqOg-Hmjs81zhI7e6O3RZLgS6Flek5T6+X9v7eWdGau2foHcaLt-qny-uffQQA
-[is-string]: https://www.typescriptlang.org/play?jsx=0#code/MYewdgzgLgBFCeAHApgeQGYwLwwBQDcBDAGwFdkAuGQseASiugCcBLMAc2wD4ZUAjAFbJgUAHSImIKFKTJR0gMpRWHUcBLECJcnVERiLYMlwAOADQwAtAEZd0gDIgA7siYBhQhGN0A3ACgEFBgASQglFU4cLTJKalo6bhgiGJgWCBhmNnZ-UEhYNPCsqlDCjmw8ZPIqGnoqSuRU9MyyrC4-GDhZDGidbCwcAHJm9gGYADIx9rwpjsDkEEx6vsGQQWEoUYmZpO0GtmgaIwXeNZFluCZyccmOjqX9qEP5zFLI-ovyKbopgB8fqdw23ueSex34QjO-Rw6BIXmuQN2qRBYCOL2UWXOMOIcK2t06KGOSyhMCG6I4Ay+-j8uWgMAUABUAErBAByAHFygNHExkABbVKICCkXkAfgGOXAtJZAFUALIAIQAoozygAmADsEryMHlqFQ9kVAEEWeUsV4tVLFQB1BnM9nlMDIJx0snsXBckA8-ksQXCmB8YiEIMACwGvj81MlIGIcmIIDdAANbay2QmLAVXbhk+y6L4YAB6fMfZCRyDR2Px3AJmUK5VpxqvXA1pWM3M+AtFs0lmnl0RxxO6-VGln1jMRXCDg3GtsdmBd0sQXv9qss63Z1PpsKZ1c2pkpmeFmAAEWQUHWMCcLCgwaRBxRzz8QA
-[is-symbol]: https://www.typescriptlang.org/play?target=7&jsx=0#code/MYewdgzgLgBFCeAHApgeQGYwLwwBQDcBDAGwFdkAuGQseASiugCcBLMAc2wD4ZUAjAFbJgUAHSImIKFKTJR0gMpRWHUcBLECJcnVERiLYMlwAOADQwAtAEZd0gDIgA7siYBhQhGN0A3ACgEFBgASQgFeABbPhBibDwiMkpqWjpuGATyGBYIGAhI6OJ-UEhYbPComKpQ8oK4rUSqGnoqDOQsnLyK2KwuPxg4WQx6nWwsHAByToLxmAAyWb6BlBBMVtGJqZjx-z9i6BgFABUAJWCAOQBxOPHHJmQIrMQIUgiAfm3d8H2zgFUAWQAQgBRY5xABMAHYil9YADUKh7ECAIJnOLoEheaElGBnIEAdSOp0ucTAyCcB2UbHYuBuIDuDxYTxeMD4xEI7IAFuNfJ9sQoAJqAhFxGoxGkABVYRCgyG5Oz2MTkxBA1IABoTzhdVRYyvkxRrLnRfDAAPQmuBMci8iCK0TKtW-QEg7XtUWaR3A45Gnym83o4hea22+24VVwhHIs4u3VdXDhxEo72+mD+wMK4hKlWh3EEk6a6NhPXu-EGi5Js0pjHIIMZu1Z9WCuH2Atu3ACoX2cvm5TkIA
-[is-type]: https://www.typescriptlang.org/play?target=7&jsx=0#code/FAFwngDgpgBAwgewHYGcQCcCuBjED0A8AKpFAHwwC8MSUA7jABQB0rAhugOYoBcMbSMAG0AugEoqFEtADcoUjAAK6AJYBbFSBUA3KCiowA5ACMVnFUhCGYAHyPGECADZQB1u4aSY1xqOndGKGA+zgGGaKpInGGYSAAmUABmFlBxhnLg0DAAYrHYBiysEBxsanwCYBKUFBUZCtJ6BADyxgBWFNSIqBg4eIQt7bZGiXlayGEIbVC4Acrqmjp6dVkAkigNBsSkZIzabE6YUOWCADQwmUcwDShb0GRVFHsHsCr6DXIWIH6JbNiwTSsYABvGAADz4Xh8fhgAF8PpZvr9-gDgTAwHwIhZOLC5PJVigAEJmFaWApPQ7HSqSGDkl76UzmSzLWBrAmOFwCMn7Cn8QQPGncukwBzOVxIZkwNa5JC4FTILnPSn82kwV45PIStYktACP6bAY7WmUs4WHUyy5dCK9fDNNr3akqtUDTUoABy3l86AVPIqysFqv0kM9LoG0xA+rtu0FxpgAGsoGAAPwYjBYv3PAMwZ14lkoADKqai3suvod-rVmKiLrzwQcTmLSrLGYrtecLoAqvEkik4g3eVTqgLm-pYglkrQ4rjsMg0AGiZwSSA+KziaTqFHFf2xHxHfSzJ9qRcEIkh4cqJRqCZ95Z0sBp905+yxcvCU-OeujVud+X6W+kNSNzPU0QF1KBjxgNlRU5AAyaDTxebpQPA0NcAkGw7EYQDYAvagelgdD4PPagficFAoAkWDzlIcCVRw+w-0MMQ5HvWdXmlWVkBfdixn-D9oy-Qi1XYw9qJPWiL2GUY5SQaxKMdRDzXA7jpJgOTywUv5kKmXBmJncNXm1EDzRfQzQIjdosJjYDQL4S0elwG0DW3QT9AGAD5LNTST2s81VLg14C0iThGB8v5mAgdAEDwC5mBY+y+mYJBSnIvyAxQkBbQs2kxCYu89IDd0oXQF9Cs9PtfW-YcaA9aFByPMT-Tozwav8GBEwDbILE0KAsIkSqgI0sCT1K6E1ObQatNaMNdIfV50pfdLzMNfiKjOeMkxTILnN3LM2hE6AaMaiTDEmKaZlSjyjK83azvDMazwAQgkrwnHrdqAsLYL1okdr1tVf8VT4PCYD4EiyJm1j80+l9Aqxcq+X6oVK2xQdGHqwimtOsNZLgy6kJPRb7oQzyhpgWGojQux0fEy9kdvOKAxrEInBh1t6z4zcKpcmAgmZ-bSZpwI2fp-LXk7McexfcXuwneHKkRzNRxl1ImzPOilfHFXKOpo7Lw1ntbzy2b1lIF8NmoW5yEs-szguPhrkt+4FbVc2KCBYAYFVE8QqhoK0dIHLgQ9z2eboTRsAACyYC4JHdkOQ+wNgyPsa8rD4dAoBATB0H-V550XXq5Hjz3E+TkwGPTzPs9z18oKQQvg-j0vYEMEYZR4wxK6znOOqk5AG+LmBm6MIM-E7mAM+7muRvQAfi+Hk7tLTieq57ual8duem6Tlu6a76vGc+reE53oXmfHyeD4Ctnj5L0-DH1icL9Xmvpc1uJj5hYOv89y+e4uNqAZTLmk3rSW2AcQYwDBlAOQcJgB3icEnfQeYEBqCgHARBKB9AglBAYAAjDIWEQ9MHINQVAIgdAEAYKQaiMABgABMhCv4MzgE0V0eYiAACV2xwCIE0ThBhaAMBQWg6hWDGC5RYWwjh3DeH8KIAAdSaII+gZMyEUKoSQiRENwwEiaE0AAMgAUQAIKugMNAnREEVgAHEViuiIAYAAnAABhcQAdjwU4px9CACsAAWdx-iXHeLweKI2s5sjtldHAPgwl1zgmqkVfkuCADUMACERPDK6dsABZAkRiBHUDwfQ9xVimgEgAFJGN4XwFE1AcF8DwTiLJWYqk1L4UQAAEoUup9TaF8BOrQawcCGYyPsTYgwhhcl0NHl6V4IsHx5gAJr5MMQYJmdZGCGDUGARiVjokABEjHZHsUYw5BhH6pCnDOUUzAnAIGCgAA1YewrhPC+GcKeSaE20ACAiPQSQnYryZEfPkUos4AKxEoByoQgA9HCqB+wyIRLuQ855ejDGmNdN8gMDQCAig5EgHYmLjFmLOOXOujEmIwARecLAUBUUuHuY8xgTyCS2PsUQXFrx8XIxJZyhxFKGSfGpfCxFeEmVQBZc8nJ+TCk8t+VAAgcydhyoKZwilcyxW0olQyqVMq2VRJiYq-F7EdjGrgBStuHEZKwt1fSw4Br0VsvGa6GxprSAEH5YwN1NiKV03tXSyVLE0WsqeRU6pvDPV-P0SsHYkaOkUqxjMINeqnWhuZS6p5Ky1kGJjcqn1ua9EGIDcLNNjrGWZuldmo5JyzmHILYwOtpzXTnIpVctIFbJVAA
-[is-undefined]: https://www.typescriptlang.org/play?jsx=0#code/MYewdgzgLgBFCeAHApgeQGYwLwwBQDcBDAGwFdkAuGQseASiugCcBLMAc2wD4ZUAjAFbJgUAHSImIKFKTJR0gMpRWHUcBLECJcnVERiLYMlwAOADQwAtAEZd0gDIgA7siYBhQhGN0A3ACgEFBgASQgAVTAAE2R0NmRI7DwiMkpqWjpuGGTyGBYIGFIomLjI-1BIWDyI6NiweKpQ6uK6hJwtFKoaeips5Fz8wpqS7j8YOFkMdp1sLBwAckHm+LmYADJV0fGUEExemfnF2uW1jbG92ZxDkv8-cugYBQAVACVggDkAcUS5xyZkAFtcogIKR-gB+OZlcD3N5hACyACEAKLPRIAJgA7FCKjAEahUPYkQBBN6JdAkLz+YjIWDUqBXFrY+5hN4AESRADF3kjWYkGfEbncQNTRMQQOxcAADJ6vT6SixVIpHSK4GXvD50XwwAD02pg5OIXlu0OFcjFEslsMRKPl-SaytwVuRz01Ph1eoNRqFIvNUrxBOJb1tiqGLVw-sJJNd7v1FOQxsgptF4qldP5kWD4SVJVwaezLWjurgTHICYgSd9kpZ7K5bx5mftOernO5rMLHrjfiAA
-
-<!-- Function: guard -->
-[guard-array]: https://www.typescriptlang.org/play?jsx=0#code/C4TwDgpgBACgTgSwLYOAgbtAvFARge3wBsIBDAOygB88EBzBc4aqcgVyKJfaVwjhYBnYInJ0hIXsRZtyAEwgAzRhDkBuAFChIUAJKCAgnDikQUHAB4AKuAgA+ABTpSRNhABcUCiACU5u1DOrtAIglBGJiDWtnaa2tAA4mykcHIRpuZQ0ZCOQW6e6VE2OX5YAXkhYYXZ9poaAMb45MJQoYWe+oWZNbku+V7kvp4VrVXGpj3+4eMgAHRtM059EH4AZKuBy63NwBT1EPiK05GajTtQdMmp7VBJKWkz3cX2S8EFMz0+w1uhxxPPATKo2qANebh8dTOLQAylYAEq6AByCUyAHIADL4OAQJCtMCCNhIAD8qNOTRaiIAqgBZABCAFE4ZkAEwAdjJ51pAHkuej6QZEZlFC5BBAOS1KYiACL0gBiSPpUsysgUynIqnFzAMcLhBgAmgB9WEI5HvSIWYSiOiAqAAbVRpFRABooKjcM7XfVUQBdTXhHX6g1UumMs0THh8OA221sl0AZlZ8bjvoa5K1AcNMAR1N0Vl0ADV6WGovBkKgMPZMrbXZbGHQPbGoCI3FAU1D07rDZKZfLEYrixYVUoVHJo0O1aoXeOR1P5MP1XI22moAApaFcwU4ADeikIngAjMy4wBfSHk4gQWZEfB0BwAA21nYNWd0ObzhbvLsu92qpZQaEwRxH0DF83wLekfAhKAAHpoKbOA3FTZoLyvG972Aw1gwZOFPwuK4HnNCN+CAjMgxpbDILUGC4ObCAkMEFDr1vB9SONJEElw79rg+WsxBIp82ORSjqPgxCoUYtCWKfbs5QVKVOPw6ppwXfjAxk3tFWE2DRLo+iJOYwSOK-RSeJEOtHEMrS4OFIhRT0khUOYrDGQUn8PiIqMHGcuErKgGy7PEhymPvbleX5RFXO480CAvChHFCvkBV8-y6MCy9grvdS5MigiJmU1RHCyvspWSkVUvPILJLXDccuqfBcAAKwgepgEcarEVK2y6KAA
-[guard-function]: https://www.typescriptlang.org/play?target=7&jsx=0#code/C4TwDgpgBAYgrgOwMZQLxQBQDodgIYBOeAtgFxR4IgCUaAfBVQNwBQokUAkgM7zLABLAPYI0mAG54ANnAjlKNelEkzoA7rERJWSEd2BR1fJIJHkex06PQYVs+VWrk7ajcfosoUdhCEAzZWlZNFR0AHI-LSswqAAyWMDVQwR9SiRfAMthUXjE4IEU4DSMqAB5ACMAKwgTVh8oAHE4QgATLJExDEjkcmNaVAZulHVNZB09AwBzZoI2qOzyJtb260wh3q0nKCHDNy0lI3mRLs3WFl1CqAAhUtKAGQBRAEEAOTE-aW4IccurzgbOC8ACpiACcAAZwQB2ACMoNBACYAKwAFihKPB8JhCB++igLwAqgBZK4PABKYhhCKhuIMAGUgWTAQ0xGEiSAoAg4MRyhACLswmcLniYASXgBhIGcUovAD6QIAmgAFB4bZCdAAe5C5PL5WwUSgA3lACBBgHACKINVAANRQJFMKAAX3OUjw3A04omBDgJiEBHFbo9UGN1vQDud5wmUHFMoZZIJktKZNl4ruTzpdLECAgAHcY97fcB-YH3dwMNQhXohFIIFgpEJJhgAAaiiVSmXy5UPZsAGig02WRwQGDbkulcsVKuolagAHo594fRAoyka3WG03m17Cj6-QGg9w+wOZnN+NkMDv9HviweyzPHQul8FynADAJ3xoEEIDO4geAV2Fdd60bDAwljF540TIFk1TdNMzCftB1mFZLzjRloNgtMMzpB950XD4pC+VduGAzcwJue5njlAA1J47gJB5EJPIdz2OSjHlePCn0I4igNrECmzCQkSXJWU6IYpikNPVCRNJMluIIz4VyAA
-[guard-number]: https://www.typescriptlang.org/play?jsx=0#code/C4TwDgpgBA4grgQwE4BMBycC2AjCSoC8UAFAG4IA2cEAXFAHZa5ICUhAfFOVdAJYDODJngDcAKFCQoASX4YceQiW7U6CeiDYFOKvoMYKk4gMYB7ev2BQB85nVm3FRMpVVR1muruv7h+bVCSEKYAZlyu0ARRUADkBswxUAD8PgBivPS8wBAuPGxeEdYWwOrGwWGO+ABkVeE8RZal5VAA8tgAVhDGwCbmllAA5oiolXTwyOh+Srlu8XgsBfUCQoYcPpUzECziYmbFUGgAqgCyAEIAogBKAPotaOdKAEwA7L37R2dX1wAqAOotSgAjC83v0Phcbt8ABKXc4PIiPEG7PpWcFfVItQ6XJQxADMLxiOz2-FMFAgADoKKYBsQAAZom53c60gA0g2Gk0MxAZt3uLG2yIspIpVJp9JOEJ+-1Z7ImGx5fxa-NBwsp1LpCphcJlQzlfm5Eq+0Nh52VgpJZLVYp5GKxOo58sNN1tl2VUAA9O7ZagoAB3UxIADW-DEQA
-[guard-object]: https://www.typescriptlang.org/play?jsx=0#code/C4TwDgpgBA4grgQwE4BMDyAjAVhAxsKAXigB5MsA+ACgHts9gAuKcgSiIqjp3ygEsAzi2wBuAFC4aAOwEFBAZWBI+UgOZEoVAG4IANnAjMEUkK2Y790QVFnK1HKKEg0AZlAsGihYgHJbK1R9xSRk5AXIGDTJsag9DKGMQABooAGsIEAB+Zn81M3c9T2tyBycIVwLLL19uBh8oADIGyqLQ41xytwjeTP4BRTtVKnTTKF6R-ikW6GYlT2YXPQEIYOlZKFVEVG6mWC30el5iaMpaQ922ZlreYuwHQR2T6mvgVnEJNYIAITQ0ABkAKIAQQAcho5isJLoEAIhGgpBAAMLQ2FQADeUAAHhoAIwiKAAXygIXWaBBAIA+oi-kD5PINAiAO4sBHImECKhvKHsqAAFUZNDZqIxIHBSAM+KJJIIvIA6mgqTS6QyIMz+YKURyuSpgBAkIsOsIeMB4dAMZjmFI4ABbDB6yX46UsL4AKQBiN5FLJAOYO1NGnNzAArITxDq9QboDt1eioCBLTa7UgHcTPs63R6KXK0L7zjHiCLg6GxB8ZDRdBAAHS6GhDAAGP3+wJBFIAakC-gBVAF1lKbZAHY1kVma6iNwGg1hvKAAehnUEWumWldLAnLVZr9fgA75AqFAl7G32j3V++o3sVtPkU-xc6PO4FSFSAgAhI5xdAIFoIFM+G5+6gUCPs+K4kuu1a1lQdbboBpr7oeAGDgww5IqOVDZpedI3rO86IUBNBPq+76eF+P78P++z4YRoFrOBm5QaemoIce5wkIx7LUBh1JXthd4QjRZYVhB9Z+gizEDo8okQOerrup63q8fO-GrnRkHQZR0YCuJ2ysZpNAyRm8nkop96AcBREQlApG-hRD4ESBYhAA
-[guard-object-key]: https://www.typescriptlang.org/play?jsx=0#code/C4TwDgpgBA4grgQwE4BMDyAjAVhAxsAaQhCgF4oAeTLAGiiJIgA9gIA7FAZygGtiB7AGZRqAPgAU-bHmAAuEdjp8Q8hgEoyoqFJz4oAS27UA3AChQkWIlTUZZSmMnT886htJaddwwqxmL0ACSnADKwEj6bADm9uIAbggANnAQ8ghsIO5aCcnQPpzhkVFmprj8bAUGoYXR8sFhEdGxOSlpGWryLXncBY0xHlDiAUJQXWSk5ADkXviTUABk86NJKQYVwOm4ECO2eovLuWsFm9vCDUUaAD6XUMPCYxNTvUWTZmXrVbvA9lTYEl1tEBKYgAfnkz2iHQOqx81E0t3Ap2h0EeUGmzmAc32Y0ixzYWx2GKgIKq52i4mUGhJyjWyKg8nCq3kgiSnAgb3KlSi1nQGPk8GQvN033IvywEhmcl8UMlVV88MMXzFEoxag5H25gq+DH5PO1xB+1DoDCgzFYHG4ykJ4qcwtcil4xFUxBlRNh2HhmpsGOVtpkVNJNSiFJdxMdJEi2iJDKQTKgLMSbLeiQQnCMbAgAGEU2moABvKBMewARmMUBI5AATGWAL5Qd6VNAAOQAogB9TMAGQAgiEQvYMwB3EQZ7OpzjiNWlHPcAAqg-4Y9zBYrt1j7KgdYb31nAHU0B2e32BxBh-PFzPJ2ZIqwkCytr4ZGgM-nC-I2HAALYYCBIMsqKAP2-X9azLbcRAAIQAKRbTNZzbZsW3tYVnxRV8mHkABWOgAMrAB2TdrzYW972gL5z1fACgJ-P9CPrTlvjQaDYPgvc0GQmQKPIFcsMI0pOX4RIIAAOkSfhgwAAwFVARyzGcAG0QAAXSgQd9GAAALERW0PXsQkUpSJLoL0hRkBgqFHGc6EmEBJgkRDdL7azbLUNUoAAenctcUmEqAWziX8QE0oo5UESIRP4ipBJEsTJOklBZKXTgDNU9StLYxz9OUoyoBM-UQAsuTx2cuzxAyrs9JK1yy08qBZ0RXKeUSmdVP4JAeE4XzMw0vAeFa9rOu8iKG2i0TxPEKSmtQpL5IALxUtTNO09sKr7AycryjFzOmqy0Vm0qHNWkIqrc2r6ssEzmvHKAwCQfhICQUB+o6rqetwPqFwG3zGWGgShLGuKpss8c5oWtLlsy0GNr1LbiEKpLrKYA6dKO6z9uqjyvPO6BLp267PpeqBut657BoTNlhMizhRtiib4sffBUPkpgwaWpiYLghDW2ZwzjJh4VtoxVDEYO5jOcQkWMdq-zAuCpofDCjNvvXSmRv+2nJsFBngCZ+bUrZsXWP3da+a1WGCq+YW9tFjmjbQE6aqxhrLtu+7fyegnBuJ97SeVnzTCAA
-[guard-primitive]: https://www.typescriptlang.org/play?target=7&jsx=0#code/C4TwDgpgBACgTgSwLYOAgbhAzlAvFAcgCMEBzBAO2AKgB9CiB7RgGwgEMKb6CKBXJEQhxuhLCEGtRBLMEQVS0vhQAmEAGaUIKggG4AUKEhQAklnjJUGaPgA8AFXAQAfAAp07FnwgAuKJxAAGigjX1hEFDRMLABKPGcoDy9oBBxHSANQqABxPnY4FQtI6zwoByc3JO8-dIhg0L8iq2i43ASqlLSnTKdTLAAhMhMqUvdPav8KEFb28c6oEnIqHuMzfuY2TlGOvwCZxLmoVIWNjgoV6DMAOQEhOG253an9jqOcfkFhC76AZTlKUgPZJPabxA7JN5QWTyUjfMw-CRMFhAiZ7MGvY7iSQsOFYACqqg0WhUKLCaLa4O8kOUak0FG0Bn0AGNGBRZG9BqRhsA-GshiN8GNgZNpn4MThFpRgGDQox1JSbLh8MQyFK9MzWezUutWGdeQNTltBTsRTExYdjkxdUaEkKqZRZJwmRA5VAdZsKFAAGRehVHNnAJ0u+UAeSIACsIEzgHFaPRXHbFfg5FS436lfh1J4sBA4j6Qk5Xa8MwxDVwYgYWQG3jdPnB9bW7qSQWa-ccPk2KbL5cWlYQO8IaAB+N4AMUoqAgibi5ohDsDFGdrsbwm9voxAaDrrDkejlc10tSfxh+uPAObptn9pw0PPFNc3fTfYIjAjUeoa7bm8XwagO-fn4bo6P6umeCixvQj69sqt4KOqVZalgCLYqeiKsBeexXvMWJIjKhY9ocJYyGhLDwQebwErSxL6pRRL0iSxqPJebY4DSdHaOihF9mxdIcfmUFccqPHEuqGrVqkTRRGEZiSSUdi1JUTEBPUTiNBEzTYK24pQLUYIAN76FARzyq4R7-AoD5ODEcQGUZRlYAA7qgTIABZQJZkA2YZdlGUy7A5gwqpUAQfhwBAwB8HAnravywDTgYPm+f50DEGWIVQGFEVRRyZbxd5Pl+QFvC3IOoXhZF0VYCucB5YlUCFSlsGKGVWWVWBpC1YlDViCR6WZRVbzIUinUFclhDCfRfXldlqS0bxKgjVAAC+3krUZ-XZVmLA5gYS2Mgh0qkHkBSyZgfi5PkhTqVJpTlJAinCrUKmQGplhSbEWGQrpFISdd1iJs9ub7eR-QhiGAAyACiACCVylFtO1iey-QmNkJhXPYpQAJwAAw4wA7AAjFjWMAEwAKwACz45TOMk4T5xI9KVx4gAsv0kMAEqlITpP4-u1Y-PYnPo9kpQEKzIBQAO9ypGRbK6gAdCwjAdQABrYVoes4oMQzDVxq8ER2XadECa2Wbi61DsPBKl1rlhWUAAPROyEcDeEjSsq+rmtBcAOuo+j9iG1AxsnX9mC+0s-uuCjaMY7bkrBdZujO67KYQJ7bDK6rrgazLzgs+zXMh2HV1vdYtgF64Rcc5ztsywQKdp27HsIV7uca01zhCyLVzZKXx3l8Ukfd64vei7bTVN47Lut5n7fZ97efm-bPfC6Lg8mxHZta2cbgT-3idpc3c8Iwvmodz7Sf+7XJdG0PptR1Kbh3-XgXRzPqdn9mF8K0vncq4lTgOvPuA8H7bwrpHauh9sgN2AV-Fu58s4QBzj7bub8t7hygWbMeb8p7mUUKfV2yCgA
-[guard-string]: https://www.typescriptlang.org/play?jsx=0#code/C4TwDgpgBA4grgQwE4BMDKwkEsB2BzKAXigAoA3BAGzggC4oBnTXPASiID4oLrosHGzfAG4AUKEhQAkgwzZ8RUjxr0EOEO0JdlfAU3l4xogMYB7HEyj85LejJsLi5KiqhqN9HVb1CCW0hIQpgBm3C7QhJFQAOSmAEYAVhDGwNFQAGTpYbxWFsBqxkGhAPKJycAZWV64TAVFUA5sUAA+zVCBIdk0RFHR+izRYmZ5UHiIqI308MjovorOvPT9+Kye4d6CBpzejQs0rEbDlmgAKgBKUgByMIrRADKmSBAAtlZgDHDPAPyDJuaWlwAqgBZABCAFEzooAEwAdiG-wqoOKxTu4IAgpdFMEqAwIId-qZKBAAHSUUx4EgAA1OF2uVIANKNxrMDCRaVcYKwDlAAPS89pIGh-CxE0nkylUoFgyGM5kzXbSiFnbnCPkCnGUPEihhiskU6nI1EYy5ysYK3wkI1ozGq9VQTXaoA
-[guard-type]: https://www.typescriptlang.org/play?target=7&jsx=0#code/C4TwDgpgBAwg9gOwM7AE4FcDGw6oDwAq4EAfFALxQIQDuUAFAHTMCGqA5kgFxQsIgBtALoBKCmSKQA3AChQkKAAVUASwC2K4CoBuEJBSgByAEYr2KhMENQAPkeNw4AGwh9rdwwnRrjEVO6MkEB9nAMMUVQR2MPQEABMIADMLCDjDWXloADFYzAMmZjA2FjUePhAxcjJyjOIoST08AHljACsySnhkNCwcfBb22yNE3K1EMLg2iGwA5XVNHT1ahQBJJAaDQmISem0WJ3QIMv4AGihMngakLcgSSrI9g+gVfQbl6ABxdDY4jcob0i7faHS7EM4XerEa4NO7iKCPQ5QF6Q6RyOprABCZhWlnyCKOvH493hwOe+lM5ks7ygmMcLj4eNJxwqcPxSPJdNcCGpaxxKD4mGg-wGO3xzLOFn5CEFPC6EV6uGabVhVRJT3ZUAGPKQOWlYwQjKezOJbORusw2oAct5fKhDSDCSzVab9F4fH5tQNpsBNiKgUbHWcANYQEAAfh4EQs7BNpI1WrRqyQAGU0NH7QTyrH1cio1Ftcngg4nBnjay47mi85tQBVeJJFJxUuO7OI5GxBLJahxWQyTCIFDsrHsHHAHiY7G4yj+h1ZnguqAUiw+1WZOCJNWI8jb+xmZfpPsDn0vDGcvjjpCn5xc5tzzdkxdng2qmfPboCiDrqBX+kGgBkf73ki77Sp+G5etgYg2HY9CvhQO49NA0FAdulCJPsSAQGIAHnMQX5sqh9hPoYIiyP23TsnywAfheVEfr6yqvuKwFSjKsBHhg2CKiKIjzhW+gDHCcGStRoFfiJ9E4S8qaROw9ASaBjBgKgcA4JkjDkfKXGoIwCAlFhUBSUgEHAEq7SviIpGHhRLzmvqF52SoiC3kSfE5vo5pwmuG4ETuhgjHqTkINYOGmiBgpfo5zmhRW4VgZqUzYGRR7sta7qoBeaW2i5FRuW2ro2n4Xl4T5caEZ4hX+FAYbslkFiaBAFlQHlb6sfFWVFTFOZxV+JnJTZxmJWONKDa03oMeZYqBlAIbhpGaZRLxQHIoJq4lShfmTGNMyGYBYVtb1Q27UBACEO5eE4JY1dJC1ybNYg1bNwFATwiHNVA6FOJh-WDjdskXjJ6bTlNd4Lnm7BCd5G2UIYW3eiFe2xQd4FHV1bY9RugOLbYdhQ75MPgwemnHimVZOADZM5UtYOU2tkD4WVflBCEThEylLx1p2jYXpzDbdlTLUah2fOpOW6qEcLXaizheOMzDkuNge1m-esxAXn8UAAqKTLTRCVxa9T-EokKZAAN4yFASIbvJKa3fQmSWVA5uW5bSA0JomAABYMA7TsWy7luYCwmG7pSVg8KgEDAOgqAGiek7ABZsgB4HwfQCYxER1HMdx5eT5J-7AdByH-mjEFhhZ9Hse1WXiAFynUDF+nbq2hXUCR1Xucdag9cp03RhwzMlc5+yJla73Rdp4Et1tx3I9-dGE8u-34Rk7P2fV9JZNL6nJcK926+d+yvNS3ES8AL7+5fltz9XmTVZRcXj-i4LEGIPCfd9Mjn72xNQOw3xUC-DVlAL4PwNbPx1g0V+kBQSQGhNsQ27ljZwheA0SBTwYFYV-k4YO+g5Q9DQHAGAuCkD6FNlAAAHgYAAjFIKAl8-4wAADIAEFkzJgMNQOgBCMBEJIXg+gVk-4YiaE0ZhABRVhloDCfwgD9H0GIVgfBWJaAgBgACcAAGLRAB2GhGiNEACYACsAAWXRZitGGJodyZWPpLQ1gALIYgkQAJVoUY3RCioDJgIG41RHwDCGCcSAKglV2RK00teRgTg4ByQAAZ4F4egfhpCkAkBYew5MCSzgAPAcQZJHFUkqQEWQnYWSOFnBSWkvBll6EAHoGnnAwBAZWMS4mJLwA4a8fASCiPEVIy0uT-6AOAZAbpT4dgDMkdIs4GdenBXqVAJpLTDjtJcLE+J9Akng36co1RBARn5KAegvZ9AlEqLUfMpclgSKkRWc0xCGyIBbK6S3PwJBHEuPcccsZ6CPmoB2N81xbj5mAvuY0p5rSXlvJ2XgPZfiAmWg+H8gpEzzlIsCfMwmyzVnPKAA
+[ts-interface]: https://www.typescriptlang.org/docs/handbook/interfaces.html#our-first-interface
+[ts-never]: https://www.typescriptlang.org/docs/handbook/basic-types.html#never
+[ts-null]: https://www.typescriptlang.org/docs/handbook/basic-types.html#null-and-undefined
+[ts-number]: https://www.typescriptlang.org/docs/handbook/basic-types.html#number
+[ts-object]: https://www.typescriptlang.org/docs/handbook/basic-types.html#object
+[ts-string]: https://www.typescriptlang.org/docs/handbook/basic-types.html#string
+[ts-undefined]: https://www.typescriptlang.org/docs/handbook/basic-types.html#null-and-undefined
+[ts-unknown]: https://www.typescriptlang.org/docs/handbook/basic-types.html#unknown
diff --git a/package-lock.json b/package-lock.json
index 909c91ce..03c1f281 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,28 +1,22 @@
 {
   "name": "@angular-package/type",
-  "version": "4.1.4",
-  "lockfileVersion": 2,
+  "version": "5.0.1-rc.0",
+  "lockfileVersion": 1,
   "requires": true,
-  "packages": {
-    "": {
-      "name": "@angular-package/type",
-      "version": "4.1.4",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.1.0"
+  "dependencies": {
+    "@angular-package/testing": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@angular-package/testing/-/testing-1.1.0.tgz",
+      "integrity": "sha512-N/c75WBG4GPcgj7NYWAKSE9IwcPSqVMOYjkZ3RU4rUZW5equkjZvQ4zWKc8S4lbxr1wPD6KxPy3T52xTsBW3Dw==",
+      "dev": true,
+      "requires": {
+        "tslib": "^2.2.0"
       }
     },
-    "node_modules/tslib": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.2.0.tgz",
-      "integrity": "sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w=="
-    }
-  },
-  "dependencies": {
     "tslib": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.2.0.tgz",
-      "integrity": "sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w=="
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.1.tgz",
+      "integrity": "sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw=="
     }
   }
 }
diff --git a/package.json b/package.json
index ebce4c22..430d52f7 100644
--- a/package.json
+++ b/package.json
@@ -1,34 +1,49 @@
 {
   "name": "@angular-package/type",
-  "version": "4.1.4",
+  "version": "5.0.0-rc.0",
   "description": "Common types, type guards and type checkers.",
   "author": "Angular Package <angular-package@wvvw.dev> (https://wvvw.dev)",
   "homepage": "https://github.com/angular-package/type#readme",
   "dependencies": {
-    "tslib": "^2.1.0"
+    "tslib": "^2.3.0"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
+  "devDependencies": {
+    "@angular-package/testing": "^2.0.0"
+  },
   "keywords": [
     "array",
     "bigint",
     "boolean",
     "check",
+    "class",
+    "date",
     "defined",
     "determine",
+    "false",
     "function",
     "guard",
     "instance",
     "key",
     "propertyKey",
+    "null",
     "number",
+    "number between",
+    "number object",
+    "number type",
     "object",
     "primitive",
+    "RegExp",
     "string",
+    "string length",
+    "string object",
+    "string type",
     "symbol",
     "undefined",
+    "true",
     "type",
     "types",
     "type guards",
diff --git a/src/are/index.ts b/src/are/index.ts
index be7c1086..dfd374d6 100644
--- a/src/are/index.ts
+++ b/src/are/index.ts
@@ -1,2 +1,15 @@
+// Object.
 export { are } from './lib/are.object';
+// Function.
+export { areBigInt } from './lib/are-bigint.func';
+export { areBoolean } from './lib/are-boolean.func';
+export { areDate } from './lib/are-date.func';
+export { areDefined } from './lib/are-defined.func';
+export { areFalse } from './lib/are-false.func';
+export { areNull } from './lib/are-null.func';
+export { areNumber } from './lib/are-number.func';
+export { areRegExp } from './lib/are-regexp.func';
 export { areString } from './lib/are-string.func';
+export { areSymbol } from './lib/are-symbol.func';
+export { areTrue } from './lib/are-true.func';
+export { areUndefined } from './lib/are-undefined.func';
diff --git a/src/are/interface/are.interface.ts b/src/are/interface/are.interface.ts
index f0158e02..39a0b3cc 100644
--- a/src/are/interface/are.interface.ts
+++ b/src/are/interface/are.interface.ts
@@ -1,4 +1,82 @@
-import { AreString } from '../type/are-string.type';
+// Function.
+import { areBigInt } from '../lib/are-bigint.func';
+import { areBoolean } from '../lib/are-boolean.func';
+import { areDate } from '../lib/are-date.func';
+import { areDefined } from '../lib/are-defined.func';
+import { areFalse } from '../lib/are-false.func';
+import { areNull } from '../lib/are-null.func';
+import { areNumber } from '../lib/are-number.func';
+import { areRegExp } from '../lib/are-regexp.func';
+import { areString } from '../lib/are-string.func';
+import { areSymbol } from '../lib/are-symbol.func';
+import { areTrue } from '../lib/are-true.func';
+import { areUndefined } from '../lib/are-undefined.func';
+/**
+ * Represents the shape of an object that contains  `are` prefixed functions.
+ */
 export interface Are {
-  string: AreString;
+  /**
+   * Checks if the values are a `bigint` type by using `every()`, `forEach()` and `some()` methods of the returned object.
+   */
+  bigint: typeof areBigInt;
+
+  /**
+   * Checks if the values are a `boolean` type or an instance of `Boolean` by using `every()`, `forEach()` and `some()` methods of the
+   * returned object.
+   */
+  boolean: typeof areBoolean;
+
+  /**
+   * Checks if the values are `Date` by using `every()`, `forEach()` and `some()` methods of the returned object.
+   */
+  date: typeof areDate;
+
+  /**
+   * Checks if the values are defined by using `every()`, `forEach()` and `some()` methods of the returned object.
+   */
+  defined: typeof areDefined;
+
+  /**
+   * Checks if the values are a `boolean` type or an instance of `Boolean` equal to `false` by using `every()`, `forEach()` and `some()`
+   * methods of the returned object.
+   */
+  false: typeof areFalse;
+
+  /**
+   * Checks if the values are `null` by using `every()`, `forEach()` and `some()` methods of the returned object.
+   */
+  null: typeof areNull;
+
+  /**
+   * Checks if the values are a `number` type or an instance of `Number` by using `every()`, `forEach()` and `some()` methods of the
+   * returned object.
+   */
+  number: typeof areNumber;
+
+  /**
+   * Checks if the values are regular expressions of `RegExp` by using `every()`, `forEach()` and `some()` methods of the returned object.
+   */
+  regexp: typeof areRegExp;
+
+  /**
+   * Checks if the values are a `string` type or an instance of `String` by using `every()`, `forEach()` and `some()` methods of the
+   * returned object.
+   */
+  string: typeof areString;
+
+  /**
+   * Checks if the values are a `symbol` type by using `every()`, `forEach()` and `some()` methods of the returned object.
+   */
+  symbol: typeof areSymbol;
+
+  /**
+   * Checks if the values are a `boolean` type or an instance of `Boolean` equal to `true` by using `every()`, `forEach()` and `some()`
+   * methods of the returned object.
+   */
+  true: typeof areTrue;
+
+  /**
+   * Checks if the values are `undefined` by using `every()`, `forEach()` and `some()` methods of the returned object.
+   */
+  undefined: typeof areUndefined;
 }
diff --git a/src/are/lib/are-bigint.func.ts b/src/are/lib/are-bigint.func.ts
new file mode 100644
index 00000000..823e35f6
--- /dev/null
+++ b/src/are/lib/are-bigint.func.ts
@@ -0,0 +1,11 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isBigInt } from '../../is/lib/is-big-int.func';
+/**
+ * Checks whether the values are a `bigint` type by using `every()`, `forEach()` and `some()` methods of the returned object.
+ * @param values A rest parameter of `any` type to check its elements against a `bigint` type.
+ * @returns The return value is an `object` of `every()`, `some()` and `forEach()` as methods of checking supplied `values`.
+ * @angularpackage
+ */
+export const areBigInt = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isBigInt, ...values);
diff --git a/src/are/lib/are-boolean.func.ts b/src/are/lib/are-boolean.func.ts
new file mode 100644
index 00000000..08e47902
--- /dev/null
+++ b/src/are/lib/are-boolean.func.ts
@@ -0,0 +1,12 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isBoolean } from '../../is/lib/is-boolean.func';
+/**
+ * Checks whether the values are a `boolean` type or an instance of `Boolean` by using `every()`, `forEach()` and `some()` methods of the
+ * returned object.
+ * @param values A rest parameter of `any` type to check its elements against a `boolean` type or an instance of `Boolean`.
+ * @returns The return value is an `object` of `every()`, `some()` and `forEach()` as methods of checking supplied `values`.
+ * @angularpackage
+ */
+export const areBoolean = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isBoolean, ...values);
diff --git a/src/are/lib/are-date.func.ts b/src/are/lib/are-date.func.ts
new file mode 100644
index 00000000..4ec2c109
--- /dev/null
+++ b/src/are/lib/are-date.func.ts
@@ -0,0 +1,11 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isDate } from '../../is/lib/is-date.func';
+/**
+ * Checks whether the values are `Date` by using `every()`, `forEach()` and `some()` methods of the returned object.
+ * @param values A rest parameter of `any` type to check its elements against `Date`.
+ * @returns The return value is an `object` of `every()`, `some()` and `forEach()` as methods of checking supplied `values`.
+ * @angularpackage
+ */
+export const areDate = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isDate, ...values);
diff --git a/src/are/lib/are-defined.func.ts b/src/are/lib/are-defined.func.ts
new file mode 100644
index 00000000..53ed4704
--- /dev/null
+++ b/src/are/lib/are-defined.func.ts
@@ -0,0 +1,11 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isDefined } from '../../is/lib/is-defined.func';
+/**
+ * Checks whether the values are defined by using `every()`, `forEach()` and `some()` methods of the returned object.
+ * @param values A rest parameter of `any` type to check whether its elements are defined.
+ * @returns The return value is an `object` of `every()`, `some()` and `forEach()` as a methods of checking supplied `values`.
+ * @angularpackage
+ */
+export const areDefined = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isDefined, ...values);
diff --git a/src/are/lib/are-determiner.func.ts b/src/are/lib/are-determiner.func.ts
new file mode 100644
index 00000000..d4c23091
--- /dev/null
+++ b/src/are/lib/are-determiner.func.ts
@@ -0,0 +1,86 @@
+// Function,
+import { isArray } from '../../is/lib/is-array.func';
+import { isFunction } from '../../is/lib/is-function.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { ForEachCallback } from '../../type/foreach-callback.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * The function returns the object of `every()`, `forEach()` and `some()` methods to check given values with the test implemented
+ * by the given `checkFn` function.
+ * @var CommonPayload The `CommonPayload` generic type variable constrained by the object constrains the generic type variable
+ * `Payload` of each returned method.
+ * @param checkFn Function to test given `values`.
+ * @param values A rest parameter of `any` type to check its elements against test given in the `checkFn` function.
+ * @returns The return value is an `object` of `every()`, `some()` and `forEach()` as methods of checking supplied `values`.
+ */
+export const areDeterminer = <CommonPayload extends object>(
+  checkFn: Function,
+  ...values: any[]
+) => {
+  return {
+    /**
+     * Checks whether every of the provided `values` pass the test implemented by the given `checkFn` function.
+     * @var Payload The `Payload` generic type variable constrained by the generic type variable `CommonPayload` indicates the type of
+     * optional parameter `payload` of the supplied `callback` function and `payload` optional parameter of the `areDeterminer().every()`
+     * method from which it captures its value.
+     * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of
+     * this check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle
+     * them before the `result` return. By default, it uses `resultCallback()` function.
+     * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback`
+     * function.
+     * @returns The return value is a `boolean` indicating whether the provided `values` passed the test implemented by the given `checkFn`
+     * function.
+     * @angularpackage
+     */
+    every: <Payload extends CommonPayload>(
+      callback: ResultCallback<any, Payload> = resultCallback,
+      payload?: Payload
+    ): boolean =>
+      callback(
+        values.every((value) => checkFn(value)),
+        values,
+        payload
+      ),
+
+    /**
+     * The `forEach()` method executes a provided callback function once for each element of the supplied `values`.
+     * @param forEachCallback A callback `function` of `ForEachCallback` type with parameters, the `value` that has been checked, the
+     * `result` of this check, `index` of each element, the provided `values` and `payload` of generic type variable `Payload` with
+     * optional properties from the provided `payload`, to handle.
+     * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback`
+     * function.
+     * @angularpackage
+     */
+    forEach: <Payload extends CommonPayload>(
+      forEachCallback: ForEachCallback<any, Payload>,
+      payload?: Payload
+    ) => {
+      isArray(values) &&
+        isFunction(forEachCallback) &&
+        values.forEach((value, index) =>
+          forEachCallback(checkFn(value), value, index, values, payload)
+        );
+    },
+
+    /**
+     * Checks whether some of the provided `values` pass the test implemented by the given `checkFn`.
+     * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of
+     * this check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle
+     * them before the `result` return. By default, it uses `resultCallback()` function.
+     * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback`
+     * function.
+     * @returns The return value is a `boolean` indicating whether some of the provided `values` passed the test of the given `checkFn`.
+     * @angularpackage
+     */
+    some: <Payload extends CommonPayload>(
+      callback: ResultCallback<any, Payload> = resultCallback,
+      payload?: Payload
+    ): boolean =>
+      callback(
+        isArray(values) ? values.some((value) => checkFn(value)) : false,
+        values,
+        payload
+      ),
+  };
+};
diff --git a/src/are/lib/are-false.func.ts b/src/are/lib/are-false.func.ts
new file mode 100644
index 00000000..e15a1c8b
--- /dev/null
+++ b/src/are/lib/are-false.func.ts
@@ -0,0 +1,12 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isFalse } from '../../is/lib/is-false.func';
+/**
+ * Checks whether the values are a `boolean` type or an instance of `Boolean` equal to `false` by using `every()`, `forEach()` and `some()`
+ * methods of the returned object.
+ * @param values A rest parameter of `any` type to check its elements against a `boolean` type or an instance of `Boolean` equal to `false`.
+ * @returns The return value is an `object` of `every()`, `some()` and `forEach()` as a methods of checking supplied `values`.
+ * @angularpackage
+ */
+export const areFalse = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isFalse, ...values);
diff --git a/src/are/lib/are-null.func.ts b/src/are/lib/are-null.func.ts
new file mode 100644
index 00000000..833a214c
--- /dev/null
+++ b/src/are/lib/are-null.func.ts
@@ -0,0 +1,11 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isNull } from '../../is/lib/is-null.func';
+/**
+ * Checks whether the values are `null` by using `every()`, `forEach()` and `some()` methods of the returned object.
+ * @param values A rest parameter of `any` type to check its elements against `null`.
+ * @returns The return value is an `object` with `every()`, `some()` and `forEach()` as a methods of checking supplied `values`.
+ * @angularpackage
+ */
+export const areNull = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isNull, ...values);
diff --git a/src/are/lib/are-number.func.ts b/src/are/lib/are-number.func.ts
new file mode 100644
index 00000000..682c73e0
--- /dev/null
+++ b/src/are/lib/are-number.func.ts
@@ -0,0 +1,12 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isNumber } from '../../is/lib/is-number.func';
+/**
+ * Checks whether the values are a `number` type or an instance of `Number` by using `every()`, `forEach()` and `some()` methods of the
+ * returned object.
+ * @param values A rest parameter of `any` type to check its elements against a `number` type or an instance of `Number`.
+ * @returns The return value is an `object` with `every()`, `some()` and `forEach()` as a methods of checking supplied values.
+ * @angularpackage
+ */
+export const areNumber = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isNumber, ...values);
diff --git a/src/are/lib/are-regexp.func.ts b/src/are/lib/are-regexp.func.ts
new file mode 100644
index 00000000..c6b4d3be
--- /dev/null
+++ b/src/are/lib/are-regexp.func.ts
@@ -0,0 +1,12 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isRegExp } from '../../is/lib/is-regexp.func';
+/**
+ * Checks whether the values are regular expressions of `RegExp` by using `every()`, `forEach()` and `some()` methods of the returned
+ * object.
+ * @param values A rest parameter of `any` type to check its elements against the regular expression of `RegExp`.
+ * @returns The return value is an `object` with `every()`, `some()` and `forEach()` as a methods of checking supplied `values`.
+ * @angularpackage
+ */
+export const areRegExp = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isRegExp, ...values);
diff --git a/src/are/lib/are-string.func.ts b/src/are/lib/are-string.func.ts
index 9f3a22aa..e5a22a2f 100644
--- a/src/are/lib/are-string.func.ts
+++ b/src/are/lib/are-string.func.ts
@@ -1,7 +1,73 @@
-import { check } from './check-args.func';
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isString } from '../../is/lib/is-string.func';
 /**
- * Checks if all the values are a `string`.
- * @param value A rest parameter of any type to check.
- * @returns A `boolean` indicating whether or not all the values are `string`.
+ * Checks if the values are a `string` type or an instance of `String` by using `every()`, `forEach()` and `some()` methods of the
+ * returned object.
+ * @param values A rest parameter of `any` type to check its elements against a `string` type or an instance of `String`.
+ * @returns The return value is an `object` with `every()`, `some()` and `forEach()` as a methods of checking supplied values.
+ * @angularpackage
  */
-export const areString = (...value: any): boolean => check('string', ...value);
+export const areString = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isString, ...values);
+
+// {
+//   return {
+//     /**
+//      * Checks if every of the provided `values` of `areString()` is a `string` type or an instance of `String`.
+//      * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of
+//      * this check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle
+//      * them before the `result` return. By default, it uses `resultCallback()` function.
+//      * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+//      * @returns The return value is a `boolean` indicating whether the provided values of `areString()` are a `string` type or an instance
+//      * of `String`.
+//      */
+//     every: <Payload extends CommonPayload>(
+//       callback: ResultCallback<any, Payload> = resultCallback,
+//       payload?: Payload
+//     ): boolean =>
+//       callback(
+//         values.every((value) => isString(value)),
+//         values,
+//         payload
+//       ),
+
+//     /**
+//      * The `forEach()` method executes a provided callback function once for each element of the supplied `values` of `areString()`.
+//      * @param forEachCallback A callback `function` of `ForEachCallback` type with parameters, the `value` that has been checked, the
+//      * `result` of this check, `index` of each element, the provided `values` and `payload` of generic type variable `Payload` with
+//      * optional properties from the provided `payload`, to handle them before the `result` return.
+//      * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+//      * @returns The return value is void.
+//      */
+//     forEach: <Payload extends CommonPayload>(
+//       forEachCallback: ForEachCallback<any, Payload>,
+//       payload?: Payload
+//     ) => {
+//       if (isArray(values) && isFunction(forEachCallback)) {
+//         values.forEach((value, index) =>
+//           forEachCallback(isString(value), value, index, values, payload)
+//         );
+//       }
+//     },
+
+//     /**
+//      * Checks if some of the provided `values` of `areString()` are a `string` type or an instance of `String`.
+//      * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of
+//      * this check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle
+//      * them before the `result` return. By default, it uses `resultCallback()` function.
+//      * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+//      * @returns The return value is a `boolean` indicating whether some of the provided values of `areString()` are a `string` type or an
+//      * instance of `String`.
+//      */
+//     some: <Payload extends CommonPayload>(
+//       callback: ResultCallback<any, Payload> = resultCallback,
+//       payload?: Payload
+//     ): boolean =>
+//       callback(
+//         isArray(values) ? values.some((value) => isString(value)) : false,
+//         values,
+//         payload
+//       ),
+//   };
+// };
diff --git a/src/are/lib/are-symbol.func.ts b/src/are/lib/are-symbol.func.ts
new file mode 100644
index 00000000..d027879c
--- /dev/null
+++ b/src/are/lib/are-symbol.func.ts
@@ -0,0 +1,11 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isSymbol } from '../../is/lib/is-symbol.func';
+/**
+ * Checks whether the values are a `symbol` type by using `every()`, `forEach()` and `some()` methods of the returned object.
+ * @param values A rest parameter of `any` type to check its elements against a `symbol` type.
+ * @returns The return value is an `object` with `every()`, `some()` and `forEach()` as a methods of checking supplied values.
+ * @angularpackage
+ */
+export const areSymbol = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isSymbol, ...values);
diff --git a/src/are/lib/are-true.func.ts b/src/are/lib/are-true.func.ts
new file mode 100644
index 00000000..784c1a20
--- /dev/null
+++ b/src/are/lib/are-true.func.ts
@@ -0,0 +1,12 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isTrue } from '../../is/lib/is-true.func';
+/**
+ * Checks whether the values are a `boolean` type or an instance of `Boolean` equal to `true` by using `every()`, `forEach()` and `some()`
+ * methods of the returned object.
+ * @param values A rest parameter of `any` type to check its elements against a `boolean` type or an instance of `Boolean` equal to `true`.
+ * @returns The return value is an `object` with `every()`, `some()` and `forEach()` as a methods of checking supplied `values`.
+ * @angularpackage
+ */
+export const areTrue = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isTrue, ...values);
diff --git a/src/are/lib/are-undefined.func.ts b/src/are/lib/are-undefined.func.ts
new file mode 100644
index 00000000..a5bdc90b
--- /dev/null
+++ b/src/are/lib/are-undefined.func.ts
@@ -0,0 +1,11 @@
+// Function.
+import { areDeterminer } from './are-determiner.func';
+import { isUndefined } from '../../is/lib/is-undefined.func';
+/**
+ * Checks whether the values are `undefined` by using `every()`, `forEach()` and `some()` methods of the returned object.
+ * @param values A rest parameter of `any` type to check its elements against `undefined`.
+ * @returns The return value is an `object` with `every()`, `some()` and `forEach()` as a methods of checking supplied values.
+ * @angularpackage
+ */
+export const areUndefined = <CommonPayload extends object>(...values: any[]) =>
+  areDeterminer<CommonPayload>(isUndefined, ...values);
diff --git a/src/are/lib/are.object.ts b/src/are/lib/are.object.ts
index cba20897..240e7eb0 100644
--- a/src/are/lib/are.object.ts
+++ b/src/are/lib/are.object.ts
@@ -1,6 +1,32 @@
-import { areString } from './are-string.func';
+// Function.
+import { areBigInt } from '../lib/are-bigint.func';
+import { areBoolean } from '../lib/are-boolean.func';
+import { areDate } from './are-date.func';
+import { areDefined } from './are-defined.func';
+import { areFalse } from './are-false.func';
+import { areNull } from '../lib/are-null.func';
+import { areNumber } from '../lib/are-number.func';
+import { areRegExp } from './are-regexp.func';
+import { areString } from '../lib/are-string.func';
+import { areSymbol } from '../lib/are-symbol.func';
+import { areTrue } from './are-true.func';
+import { areUndefined } from '../lib/are-undefined.func';
+// Interface.
 import { Are } from '../interface/are.interface';
-
-export const are: Are = {
-  string: areString
-};
+/**
+ * The `object` consists of `are` prefixed functions.
+ */
+export const are: Are = Object.freeze({
+  bigint: areBigInt, // From the `5.0.0` version.
+  boolean: areBoolean, // From the `5.0.0` version.
+  date: areDate, // From the `5.0.0` version.
+  defined: areDefined, // From the `5.0.0` version.
+  false: areFalse, // From the `5.0.0` version.
+  null: areNull, // From the `5.0.0` version.
+  number: areNumber, // From the `5.0.0` version.
+  regexp: areRegExp, // From the `5.0.0` version.
+  string: areString,
+  symbol: areSymbol, // From the `5.0.0` version.
+  true: areTrue, // From the `5.0.0` version.
+  undefined: areUndefined // From the `5.0.0` version.
+});
diff --git a/src/are/lib/check-args.func.ts b/src/are/lib/check-args.func.ts
deleted file mode 100644
index 82d112cb..00000000
--- a/src/are/lib/check-args.func.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import { isString } from '../../is/lib/is-string.func';
-import { IsString } from '../../is/type/is-string.type';
-import { Primitives } from '../../type/primitives.type';
-export const check = (type: Primitives, ...args: any): boolean => {
-  let result = true;
-  let method: IsString;
-  switch (type) {
-    case 'string': method = isString; break;
-    default: method = isString; break;
-  }
-  for (const arg of args) {
-    result = method(arg);
-    if (result === false) {
-      break;
-    }
-  }
-  return result;
-};
diff --git a/src/are/test/are-bigint.spec.ts b/src/are/test/are-bigint.spec.ts
new file mode 100644
index 00000000..60966b17
--- /dev/null
+++ b/src/are/test/are-bigint.spec.ts
@@ -0,0 +1,63 @@
+
+import { areBigInt } from '../lib/are-bigint.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.bigint.describe,
+  tests.are.bigint.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areBigInt.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areBigInt).toBeDefined())
+    .it(`every()`, () => {
+      areBigInt(1n, '2n', 3, 4n).every(
+        (result, value, payload) => {
+          expect(value).toEqual([1n, '2n', 3, 4n]);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areBigInt(1n, '2n', 3, 4n).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areBigInt(1n, '2n', 3, 4n).some(
+        (result, value, payload) => {
+          expect(value).toEqual([1n, '2n', 3, 4n]);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/test/are-boolean.spec.ts b/src/are/test/are-boolean.spec.ts
new file mode 100644
index 00000000..ebe73973
--- /dev/null
+++ b/src/are/test/are-boolean.spec.ts
@@ -0,0 +1,64 @@
+import { areBoolean } from '../lib/are-boolean.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.boolean.describe,
+  tests.are.boolean.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areBoolean.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areBoolean).toBeDefined())
+    .it(`every()`, () => {
+      areBoolean(1, true, null, new Boolean(3)).every(
+        (result, value, payload) => {
+          expect(result).toBeFalse();
+          expect(value).toEqual([1, true, null, new Boolean(3)]);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areBoolean(1, true, null, new Boolean(3)).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areBoolean(1, true, null, new Boolean(3)).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual([1, true, null, new Boolean(3)]);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/test/are-date.spec.ts b/src/are/test/are-date.spec.ts
new file mode 100644
index 00000000..73e58228
--- /dev/null
+++ b/src/are/test/are-date.spec.ts
@@ -0,0 +1,66 @@
+import { areDate } from '../lib/are-date.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.date.describe,
+  tests.are.date.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areDate.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areDate).toBeDefined())
+    .it(`every()`, () => {
+      const arr = [new Date(), new Date('invalid date')];
+      areDate(...arr).every(
+        (result, value, payload) => {
+          expect(result).toBeFalse();
+          expect(value).toEqual(arr);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areDate(new Date(), new Date('invalid date')).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      const arr = [new Date(), new Date('invalid date')];
+      areDate(...arr).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(arr);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/test/are-defined.spec.ts b/src/are/test/are-defined.spec.ts
new file mode 100644
index 00000000..cff156df
--- /dev/null
+++ b/src/are/test/are-defined.spec.ts
@@ -0,0 +1,65 @@
+import { areDefined } from '../lib/are-defined.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.defined.describe,
+  tests.are.defined.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areDefined.name, () => {
+  let age: any;
+  const arr = ['1', 2, null, undefined, age];
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areDefined).toBeDefined())
+    .it(`every()`, () => {
+      areDefined(...arr).every(
+        (result, value, payload) => {
+          expect(value).toEqual(arr);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areDefined('1', 2, null, undefined, age).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areDefined(...arr).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(arr);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/test/are-false.spec.ts b/src/are/test/are-false.spec.ts
new file mode 100644
index 00000000..bca9d7b2
--- /dev/null
+++ b/src/are/test/are-false.spec.ts
@@ -0,0 +1,65 @@
+import { areFalse } from '../lib/are-false.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.false.describe,
+  tests.are.false.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areFalse.name, () => {
+  const arr = [true, null, false, new Boolean(false)];
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areFalse).toBeDefined())
+    .it(`every()`, () => {
+      areFalse(...arr).every(
+        (result, value, payload) => {
+          expect(result).toBeFalse();
+          expect(value).toEqual(arr);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areFalse(true, null, false, new Boolean(false)).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areFalse(...arr).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(arr);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/test/are-null.spec.ts b/src/are/test/are-null.spec.ts
new file mode 100644
index 00000000..5aa069f4
--- /dev/null
+++ b/src/are/test/are-null.spec.ts
@@ -0,0 +1,63 @@
+import { areNull } from '../lib/are-null.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.null.describe,
+  tests.are.null.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areNull.name, () => {
+  const arr = [null, undefined, false, !!null];
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areNull).toBeDefined())
+    .it(`every()`, () => {
+      areNull(...arr).every(
+        (result, value, payload) => {
+          expect(value).toEqual(arr);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areNull(null, undefined, false, !!null).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areNull(...arr).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(arr);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/test/are-number.spec.ts b/src/are/test/are-number.spec.ts
new file mode 100644
index 00000000..544b9c02
--- /dev/null
+++ b/src/are/test/are-number.spec.ts
@@ -0,0 +1,64 @@
+import { areNumber } from '../lib/are-number.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.number.describe,
+  tests.are.number.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areNumber.name, () => {
+  const arr = [1, new Number(2), Number(3), '4'];
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areNumber).toBeDefined())
+    .it(`every()`, () => {
+      areNumber(...arr).every(
+        (result, value, payload) => {
+          expect(value).toEqual(arr);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areNumber(1, new Number(2), Number(3), '4').forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areNumber(...arr).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(arr);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/test/are-regexp.spec.ts b/src/are/test/are-regexp.spec.ts
new file mode 100644
index 00000000..7d215d20
--- /dev/null
+++ b/src/are/test/are-regexp.spec.ts
@@ -0,0 +1,64 @@
+import { areRegExp } from '../lib/are-regexp.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.regexp.describe,
+  tests.are.regexp.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areRegExp.name, () => {
+  const arr = [/^[]/, /^[]/, /^[]/, 3];
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areRegExp).toBeDefined())
+    .it(`every()`, () => {
+      areRegExp(...arr).every(
+        (result, value, payload) => {
+          expect(value).toEqual(arr);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areRegExp(...arr).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areRegExp(...arr).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(arr);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/test/are-string.spec.ts b/src/are/test/are-string.spec.ts
index aa8b174b..3cb27b11 100644
--- a/src/are/test/are-string.spec.ts
+++ b/src/are/test/are-string.spec.ts
@@ -1,21 +1,65 @@
 
 import { areString } from '../lib/are-string.func';
-
-describe(areString.name, () => {
-
-  beforeEach(async () => {});
-
-  beforeEach(() => {});
-
-  it('is DEFINED', () => expect(areString).toBeDefined());
-
-  it(`string to be TRUE`, () => expect(areString('one', 'two', 'three')).toBeTruthy());
-
-  it(`number to be FALSE`, () => expect(areString(1, 2, 3)).toBeFalsy());
-
-  it(`boolean to be FALSE`, () => expect(areString(true, false, false)).toBeFalsy());
-
-  it(`string with number to be FALSE`, () => expect(areString('one', 'two', 'three', 3)).toBeFalse());
-
-  it(`string with array to be FALSE`, () => expect(areString('one', 'two', 'three', ['3'])).toBeFalse());
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.string.describe,
+  tests.are.string.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areString.name, () => {
+  const arr = [1, '2', '3'];
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areString).toBeDefined())
+    .it(`every()`, () => {
+      areString(...arr).every(
+        (result, value, payload) => {
+          expect(value).toEqual(arr);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areString(...arr).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areString(...arr).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(arr);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
 });
diff --git a/src/are/test/are-symbol.spec.ts b/src/are/test/are-symbol.spec.ts
new file mode 100644
index 00000000..ecc8c38a
--- /dev/null
+++ b/src/are/test/are-symbol.spec.ts
@@ -0,0 +1,65 @@
+// Function to test.
+import { areSymbol } from '../lib/are-symbol.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.symbol.describe,
+  tests.are.symbol.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areSymbol.name, () => {
+  const arr = [Symbol(1), 2, Symbol(3), 4];
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areSymbol).toBeDefined())
+    .it(`every()`, () => {
+      areSymbol(...arr).every(
+        (result, value, payload) => {
+          expect(value).toEqual(arr);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areSymbol(...arr).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areSymbol(...arr).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(arr);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/test/are-true.spec.ts b/src/are/test/are-true.spec.ts
new file mode 100644
index 00000000..4240f513
--- /dev/null
+++ b/src/are/test/are-true.spec.ts
@@ -0,0 +1,65 @@
+// Function to test.
+import { areTrue } from '../lib/are-true.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.true.describe,
+  tests.are.true.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areTrue.name, () => {
+  const arr = [true, null, false, new Boolean(false)];
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areTrue).toBeDefined())
+    .it(`every()`, () => {
+      areTrue(...arr).every(
+        (result, value, payload) => {
+          expect(value).toEqual(arr);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areTrue(...arr).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areTrue(...arr).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(arr);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/test/are-undefined.spec.ts b/src/are/test/are-undefined.spec.ts
new file mode 100644
index 00000000..5e898f15
--- /dev/null
+++ b/src/are/test/are-undefined.spec.ts
@@ -0,0 +1,66 @@
+
+// Function to test.
+import { areUndefined } from '../lib/are-undefined.func';
+// Testing.
+import {
+  Testing,
+  TestingToBeMatchers,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.are.undefined.describe,
+  tests.are.undefined.it
+);
+const toBe = new TestingToBeMatchers();
+/**
+ * Tests.
+ */
+testing.describe(areUndefined.name, () => {
+  const arr = [undefined, 1, 2, '3'];
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(areUndefined).toBeDefined())
+    .it(`every()`, () => {
+      areUndefined(...arr).every(
+        (result, value, payload) => {
+          expect(value).toEqual(arr);
+          toBe
+            .false(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    })
+    .it(`forEach()`, () => {
+      areUndefined(...arr).forEach(
+        (result, value, index, array, payload) => {
+          expect(value).toEqual(array[index]);
+          toBe
+            .boolean(result)
+            .number(index)
+            .array(array)
+            .object(payload);
+          expect(payload?.age).toEqual(2);
+        },
+        { age: 2 }
+      );
+    })
+    .it(`some()`, () => {
+      areUndefined(...arr).some(
+        (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(arr);
+          toBe
+            .true(result)
+            .array(value)
+            .undefined(payload);
+          return result;
+        }
+      );
+    });
+});
diff --git a/src/are/type/are-string.type.ts b/src/are/type/are-string.type.ts
deleted file mode 100644
index 00db2654..00000000
--- a/src/are/type/are-string.type.ts
+++ /dev/null
@@ -1 +0,0 @@
-export type AreString = (...value: any) => boolean;
diff --git a/src/execute-tests.ts b/src/execute-tests.ts
new file mode 100644
index 00000000..589af52f
--- /dev/null
+++ b/src/execute-tests.ts
@@ -0,0 +1,130 @@
+export const tests = {
+  /**
+   * Switches for the `are` prefixed functions.
+   */
+  are: {
+    bigint: { describe: true, it: true },
+    boolean: { describe: true, it: true },
+    date: { describe: true, it: true },
+    defined: { describe: true, it: true },
+    false: { describe: true, it: true },
+    null: { describe: true, it: true },
+    number: { describe: true, it: true },
+    regexp: { describe: true, it: true },
+    string: { describe: true, it: true },
+    symbol: { describe: true, it: true },
+    true: { describe: true, it: true },
+    undefined: { describe: true, it: true },
+  },
+  object: {
+    guard: { describe: true, it: true },
+    is: { describe: true, it: true },
+    isNot: { describe: true, it: true },
+  },
+
+  /**
+   * Switches for the experimental.
+   */
+  experimental: {
+    bigint: { describe: true, it: true },
+    boolean: { describe: true, it: true },
+    number: { describe: true, it: true },
+    string: { describe: true, it: true },
+    symbol: { describe: true, it: true },
+  },
+
+  /**
+   * Switches for the `guard` prefixed functions.
+   */
+  guard: {
+    array: { describe: true, it: true },
+    bigint: { describe: true, it: true },
+    boolean: { describe: true, it: true },
+    class: { describe: true, it: true },
+    date: { describe: true, it: true },
+    defined: { describe: true, it: true },
+    false: { describe: true, it: true },
+    function: { describe: true, it: true },
+    instance: { describe: true, it: true },
+    key: { describe: true, it: true },
+    null: { describe: true, it: true },
+    number: { describe: true, it: true },
+    numberBetween: { describe: true, it: true },
+    object: { describe: true, it: true },
+    objectKey: { describe: true, it: true },
+    objectKeyIn: { describe: true, it: true },
+    objectKeys: { describe: true, it: true },
+    objectKeysIn: { describe: true, it: true },
+    objectSomeKeys: { describe: true, it: true },
+    primitive: { describe: true, it: true },
+    regexp: { describe: true, it: true },
+    string: { describe: true, it: true },
+    stringIncludes: { describe: true, it: true },
+    stringIncludesSome: { describe: true, it: true },
+    stringLength: { describe: true, it: true },
+    stringLengthBetween: { describe: true, it: true },
+    symbol: { describe: true, it: true },
+    true: { describe: true, it: true },
+    type: { describe: true, it: true },
+    undefined: { describe: true, it: true },
+  },
+
+  /**
+   * Switches for the `is` prefixed functions.
+   */
+  is: {
+    array: { describe: true, it: true },
+    bigint: { describe: true, it: true },
+    boolean: { describe: true, it: true },
+    booleanObject: { describe: true, it: true },
+    booleanType: { describe: true, it: true },
+    class: { describe: true, it: true },
+    date: { describe: true, it: true },
+    defined: { describe: true, it: true },
+    false: { describe: true, it: true },
+    function: { describe: true, it: true },
+    instance: { describe: true, it: true },
+    key: { describe: true, it: true },
+    not: {
+      boolean: { describe: true, it: true },
+      defined: { describe: true, it: true },
+      function: { describe: true, it: true },
+      null: { describe: true, it: true },
+      number: { describe: true, it: true },
+      string: { describe: true, it: true },
+      undefined: { describe: true, it: true },
+    },
+    null: { describe: true, it: true },
+    number: { describe: true, it: true },
+    numberBetween: { describe: true, it: true },
+    numberObject: { describe: true, it: true },
+    numberType: { describe: true, it: true },
+    object: { describe: true, it: true },
+    objectKey: { describe: true, it: true },
+    objectKeyIn: { describe: true, it: true },
+    objectKeys: { describe: true, it: true },
+    objectKeysIn: { describe: true, it: true },
+    objectSomeKeys: { describe: true, it: true },
+    param: { describe: true, it: true },
+    primitive: { describe: true, it: true },
+    regexp: { describe: true, it: true },
+    string: { describe: true, it: true },
+    stringIncludes: { describe: true, it: true },
+    stringIncludesSome: { describe: true, it: true },
+    stringLength: { describe: true, it: true },
+    stringLengthBetween: { describe: true, it: true },
+    stringObject: { describe: true, it: true },
+    stringType: { describe: true, it: true },
+    symbol: { describe: true, it: true },
+    true: { describe: true, it: true },
+    type: { describe: true, it: true },
+    undefined: { describe: true, it: true }
+  },
+
+  /**
+   * Switches for the recognize.
+   */
+  recognize: {
+    recognizeValue: { describe: true, it: true }
+  },
+};
diff --git a/src/guard/index.ts b/src/guard/index.ts
index bed82223..8ef86119 100644
--- a/src/guard/index.ts
+++ b/src/guard/index.ts
@@ -5,17 +5,29 @@ export { guardArray } from './lib/guard-array.func';
 export { guardBigInt } from './lib/guard-big-int.func';
 export { guardBoolean } from './lib/guard-boolean.func';
 export { guardClass } from './lib/guard-class.func';
+export { guardDate  } from './lib/guard-date.func';
 export { guardDefined } from './lib/guard-defined.func';
+export { guardFalse  } from './lib/guard-false.func';
 export { guardFunction } from './lib/guard-function.func';
 export { guardInstance } from './lib/guard-instance.func';
 export { guardKey } from './lib/guard-key.func';
-export { guardNumber } from './lib/guard-number.func';
 export { guardNull } from './lib/guard-null.func';
+export { guardNumber } from './lib/guard-number.func';
+export { guardNumberBetween } from './lib/guard-number-between.func';
 export { guardObject } from './lib/guard-object.func';
 export { guardObjectKey } from './lib/guard-object-key.func';
+export { guardObjectKeyIn } from './lib/guard-object-key-in.func';
+export { guardObjectKeysIn } from './lib/guard-object-keys-in.func';
 export { guardObjectKeys } from './lib/guard-object-keys.func';
+export { guardObjectSomeKeys } from './lib/guard-object-some-keys.func';
 export { guardPrimitive } from './lib/guard-primitive.func';
+export { guardRegExp } from './lib/guard-regexp.func';
 export { guardString } from './lib/guard-string.func';
+export { guardStringIncludes } from './lib/guard-string-includes.func';
+export { guardStringIncludesSome } from './lib/guard-string-includes-some.func';
+export { guardStringLength } from './lib/guard-string-length.func';
+export { guardStringLengthBetween } from './lib/guard-string-length-between.func';
 export { guardSymbol } from './lib/guard-symbol.func';
+export { guardTrue } from './lib/guard-true.func';
 export { guardType } from './lib/guard-type.func';
 export { guardUndefined } from './lib/guard-undefined.func';
diff --git a/src/guard/interface/guard-are.interface.ts b/src/guard/interface/guard-are.interface.ts
deleted file mode 100644
index 6c5e8666..00000000
--- a/src/guard/interface/guard-are.interface.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-
-export interface GuardAre { }
diff --git a/src/guard/interface/guard-interface.ts b/src/guard/interface/guard-interface.ts
index d2c8afe0..ba811e36 100644
--- a/src/guard/interface/guard-interface.ts
+++ b/src/guard/interface/guard-interface.ts
@@ -1,4 +1,6 @@
+// Interface.
 import { GuardIs } from './guard-is.interface';
-export interface Guard {
-  is: GuardIs;
-}
+/**
+ * The shape of an object with guard functions.
+ */
+export interface Guard extends GuardIs { }
diff --git a/src/guard/interface/guard-is.interface.ts b/src/guard/interface/guard-is.interface.ts
index 0a2a1148..d5c25c43 100644
--- a/src/guard/interface/guard-is.interface.ts
+++ b/src/guard/interface/guard-is.interface.ts
@@ -1,39 +1,154 @@
-import { GuardArray } from '../type/guard-array.type';
-import { GuardBigInt } from '../type/guard-big-int.type';
-import { GuardBoolean } from '../type/guard-boolean.type';
-import { GuardClass } from '../type/guard-class.type';
-import { GuardDefined } from '../type/guard-defined.type';
-import { GuardFunction } from '../type/guard-function.type';
-import { GuardKey } from '../type/guard-key.type';
-import { GuardNumber } from '../type/guard-number.type';
-import { GuardObject } from '../type/guard-object.type';
-import { GuardObjectKey } from '../type/guard-object-key.type';
-import { GuardObjectKeys } from '../type/guard-object-keys.type';
-import { GuardPrimitive } from '../type/guard-primitive.type';
-import { GuardString } from '../type/guard-string.type';
-import { GuardType } from '../type/guard-type.type';
-import { GuardInstance } from '../type/guard-instance.type';
-import { GuardNull } from '../type/guard-null.type';
-import { GuardSymbol } from '../type/guard-symbol.type';
-import { GuardUndefined } from '../type/guard-undefined.type';
-
+// Function.
+import { guardArray } from '../lib/guard-array.func';
+import { guardBigInt } from '../lib/guard-big-int.func';
+import { guardBoolean } from '../lib/guard-boolean.func';
+import { guardClass } from '../lib/guard-class.func';
+import { guardDate } from '../lib/guard-date.func';
+import { guardDefined } from '../lib/guard-defined.func';
+import { guardFalse } from '../lib/guard-false.func';
+import { guardFunction } from '../lib/guard-function.func';
+import { guardInstance } from '../lib/guard-instance.func';
+import { guardKey } from '../lib/guard-key.func';
+import { guardNull } from '../lib/guard-null.func';
+import { guardNumber } from '../lib/guard-number.func';
+import { guardNumberBetween } from '../lib/guard-number-between.func';
+import { guardObject } from '../lib/guard-object.func';
+import { guardObjectKey } from '../lib/guard-object-key.func';
+import { guardObjectKeyIn } from '../lib/guard-object-key-in.func';
+import { guardObjectKeys } from '../lib/guard-object-keys.func';
+import { guardObjectKeysIn } from '../lib/guard-object-keys-in.func';
+import { guardObjectSomeKeys } from '../lib/guard-object-some-keys.func';
+import { guardPrimitive } from '../lib/guard-primitive.func';
+import { guardRegExp } from '../lib/guard-regexp.func';
+import { guardString } from '../lib/guard-string.func';
+import { guardStringIncludes } from '../lib/guard-string-includes.func';
+import { guardStringIncludesSome } from '../lib/guard-string-includes-some.func';
+import { guardStringLength } from '../lib/guard-string-length.func';
+import { guardStringLengthBetween } from '../lib/guard-string-length-between.func';
+import { guardSymbol } from '../lib/guard-symbol.func';
+import { guardTrue } from '../lib/guard-true.func';
+import { guardType } from '../lib/guard-type.func';
+import { guardUndefined } from '../lib/guard-undefined.func';
+// Export: Interface.
 export interface GuardIs {
-  array: GuardArray;
-  bigint: GuardBigInt;
-  boolean: GuardBoolean;
-  class: GuardClass;
-  defined: GuardDefined;
-  function: GuardFunction;
-  instance: GuardInstance;
-  key: GuardKey;
-  null: GuardNull;
-  number: GuardNumber;
-  object: GuardObject;
-  objectKey: GuardObjectKey;
-  objectKeys: GuardObjectKeys,
-  primitive: GuardPrimitive;
-  string: GuardString;
-  symbol: GuardSymbol;
-  type: GuardType;
-  undefined: GuardUndefined;
+  /**
+   * Guards the value to be an `array` of a generic type variable `Type`.
+   */
+  array: typeof guardArray;
+  /**
+   * Guards the value to be a `bigint`.
+   */
+  bigint: typeof guardBigInt;
+  /**
+   * Guards the value to be `boolean` of any type.
+   */
+  boolean: typeof guardBoolean;
+  /**
+   * Guards the value to be a `class` of generic type variable `Class`.
+   */
+  class: typeof guardClass;
+  /**
+   * Guards the value to be a date.
+   */
+  date: typeof guardDate;
+  /**
+   * Guards the value to be defined, not `undefined`.
+   */
+  defined: typeof guardDefined;
+  /**
+   * Guards the provided value to be `false`.
+   */
+  false: typeof guardFalse;
+  /**
+   * Guards the value to be a `Function`.
+   */
+  function: typeof guardFunction;
+  /**
+   * Guards the value to be an instance of the given `constructor`.
+   */
+  instance: typeof guardInstance;
+  /**
+   * Guards the value to be one of `string`, `number`, or `symbol` type.
+   */
+  key: typeof guardKey;
+  /**
+   * Guards the value to be `null`.
+   */
+  null: typeof guardNull;
+  /**
+   * Guards the value to be a `number` of any type.
+   */
+  number: typeof guardNumber;
+  /**
+   * Guards the value to be `number` between the specified range.
+   */
+  numberBetween: typeof guardNumberBetween;
+  /**
+   * Guards the value to be an `object` of a generic type variable `Obj`.
+   */
+  object: typeof guardObject;
+  /**
+   * Guards the value to be an `object` of generic type variable `Obj` that contains the given `key`.
+   */
+  objectKey: typeof guardObjectKey;
+  /**
+   * Guards the value to be an `object` of a generic type variable `Obj` that contains(or its prototype chain) the given `key`.
+   */
+  objectKeyIn: typeof guardObjectKeyIn;
+  /**
+   * Guards the value to be an `object` of a generic type variable `Obj` with its specified `keys`.
+   */
+  objectKeys: typeof guardObjectKeys;
+  /**
+   * Guards the value to be an `object` of a generic type variable `Obj` with specified keys in it(or its prototype chain).
+   */
+  objectKeysIn: typeof guardObjectKeysIn;
+  /**
+   * Guards the value to be an `object` of a generic type variable `Obj` with its specified `keys`.
+   */
+  objectSomeKeys: typeof guardObjectSomeKeys;
+  /**
+   * Guards the value to be the `Primitive` type or the given `type` of the `Primitives`.
+   */
+  primitive: typeof guardPrimitive;
+  /**
+   * Guards the value to be a `RegExp`.
+   */
+  regexp: typeof guardRegExp;
+  /**
+   * Guards the value to be `string` of any type.
+   */
+  string: typeof guardString;
+  /**
+   * Guards the value to be a `string` type or an instance of `String` that includes all of the specified words/sentences.
+   */
+  stringIncludes: typeof guardStringIncludes;
+  /**
+   * Guards the value to be a `string` type or an instance of `String` that includes some of the specified words/sentences.
+   */
+  stringIncludesSome: typeof guardStringIncludesSome;
+  /**
+   * Guards the value to be `string` type or `String` instance of a specified length.
+   */
+  stringLength: typeof guardStringLength;
+  /**
+   * Guards the value to be `string` or `String` instance of a length between the specified range.
+   */
+  stringLengthBetween: typeof guardStringLengthBetween;
+  /**
+   * Guards the value to be a `symbol`.
+   */
+  symbol: typeof guardSymbol;
+  /**
+   * Guards the value to be `true`.
+   */
+  true: typeof guardTrue;
+  /**
+   * Guards the value to be a type from a given `type`.
+   */
+  type: typeof guardType;
+  /**
+   * Guards the value to be `undefined`.
+   */
+  undefined: typeof guardUndefined;
 }
diff --git a/src/guard/lib/guard-array.func.ts b/src/guard/lib/guard-array.func.ts
index 1fbf6617..3169574b 100644
--- a/src/guard/lib/guard-array.func.ts
+++ b/src/guard/lib/guard-array.func.ts
@@ -1,15 +1,16 @@
 // Function.
 import { isArray } from '../../is/lib/is-array.func';
 // Type.
-import { GuardArray } from '../type/guard-array.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be an `Array` of a generic `Type`.
- * @param value An `Array` of a generic `Type`, by default type detected from the `value` - to guard.
+ * Guards the value to be an `array` of a generic type variable `Type`.
+ * @param value An `array` of generic type variable `Type` to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is an `Array` of a generic `Type`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return `value` is a `boolean` indicating whether the `value` is an `array` of a generic type variable `Type`.
  */
-export const guardArray: GuardArray = <Type>(
+export const guardArray = <Type, Payload extends object = object>(
   value: Array<Type>,
-  callback?: ResultCallback
-): value is Array<Type> => isArray<Type>(value, callback);
+  callback?: ResultCallback<Array<Type>, Payload>,
+  payload?: Payload
+): value is Array<Type> => isArray(value, callback, payload);
diff --git a/src/guard/lib/guard-big-int.func.ts b/src/guard/lib/guard-big-int.func.ts
index 0dced265..d316d589 100644
--- a/src/guard/lib/guard-big-int.func.ts
+++ b/src/guard/lib/guard-big-int.func.ts
@@ -1,15 +1,19 @@
 // Function.
 import { isBigInt } from '../../is/lib/is-big-int.func';
 // Type.
-import { GuardBigInt } from '../type/guard-big-int.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be a `bigint`.
- * @param value A `bigint` type `value` to guard.
+ * Guards the value to be a `bigint`.
+ * @param value A `bigint` type value to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `bigint`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return `value` is a `boolean` indicating whether the `value` is a `bigint`.
  */
-export const guardBigInt: GuardBigInt = (
-  value: bigint,
-  callback?: ResultCallback
-): value is bigint => isBigInt(value, callback);
+export const guardBigInt = <
+  BigInt extends bigint,
+  Payload extends object = object
+>(
+  value: BigInt,
+  callback?: ResultCallback<BigInt, Payload>,
+  payload?: Payload
+): value is BigInt => isBigInt(value, callback, payload);
diff --git a/src/guard/lib/guard-boolean.func.ts b/src/guard/lib/guard-boolean.func.ts
index a14ed2c8..4fd18fae 100644
--- a/src/guard/lib/guard-boolean.func.ts
+++ b/src/guard/lib/guard-boolean.func.ts
@@ -2,15 +2,19 @@
 import { isBoolean } from '../../is/lib/is-boolean.func';
 // Type.
 import { AnyBoolean } from '../../type/any-boolean.type';
-import { GuardBoolean } from '../type/guard-boolean.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be any type of a boolean.
- * @param value An `AnyBoolean` type `value`, by default of type detected from the `value` - to guard.
+ * Guards the value to be `boolean` of any type.
+ * @param value The value of generic type variable `Type` to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `boolean` type or `Boolean` object.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `boolean` type or an instance of `Boolean`.
  */
-export const guardBoolean: GuardBoolean = <B extends AnyBoolean>(
-  value: B,
-  callback?: ResultCallback
-): value is B => isBoolean(value, callback);
+export const guardBoolean = <
+  Type extends AnyBoolean,
+  Payload extends object = object
+>(
+  value: Type,
+  callback?: ResultCallback<Type, Payload>,
+  payload?: Payload
+): value is Type => isBoolean(value, callback, payload);
diff --git a/src/guard/lib/guard-class.func.ts b/src/guard/lib/guard-class.func.ts
index fb238967..b887be68 100644
--- a/src/guard/lib/guard-class.func.ts
+++ b/src/guard/lib/guard-class.func.ts
@@ -1,16 +1,19 @@
 // Function.
 import { isClass } from '../../is/lib/is-class.func';
 // Type.
-import { GuardClass } from '../type/guard-class.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be a generic `Class` type of `class`.
- * @param value A `Function` type `value`, by default of a generic `Class` type detected from the `value` to guard.
+ * Guards the value to be a `class` of generic type variable `Class`.
+ * @param value The `class` of a generic type variable `Class` to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a generic `class`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `class` of a generic type variable `Class`.
  */
-// tslint:disable-next-line: ban-types
-export const guardClass: GuardClass = <Class extends Function>(
+export const guardClass = <
+  Class extends Function,
+  Payload extends object = object
+>(
   value: Class,
-  callback?: ResultCallback
-): value is Class => isClass<Class>(value, callback);
+  callback?: ResultCallback<Class, Payload>,
+  payload?: Payload
+): value is Class => isClass(value, callback, payload);
diff --git a/src/guard/lib/guard-date.func.ts b/src/guard/lib/guard-date.func.ts
new file mode 100644
index 00000000..1f713509
--- /dev/null
+++ b/src/guard/lib/guard-date.func.ts
@@ -0,0 +1,16 @@
+// Function.
+import { isDate } from '../../is/lib/is-date.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guards the value to be a date.
+ * @param value The value of `Date` type to guard.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the value is a date.
+ */
+export const guardDate = <Payload extends object>(
+  value: Date,
+  callback?: ResultCallback<Date, Payload>,
+  payload?: Payload
+): value is Date => isDate(value, callback, payload);
diff --git a/src/guard/lib/guard-defined.func.ts b/src/guard/lib/guard-defined.func.ts
index edd4ece7..601a5adc 100644
--- a/src/guard/lib/guard-defined.func.ts
+++ b/src/guard/lib/guard-defined.func.ts
@@ -2,15 +2,16 @@
 import { isDefined } from '../../is/lib/is-defined.func';
 // Type.
 import { Defined } from '../../type/defined.type';
-import { GuardDefined } from '../type/guard-defined.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be defined, not `undefined`.
- * @param value A generic type `value`, by default of `Defined<Type>` type detected from the `value` to guard against `undefined`.
+ * Guards the value to be defined, not `undefined`.
+ * @param value The value of generic type `Defined<Type>`, never undefined type captured from itself to guard against `undefined`.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is defined, if `undefined` then returns `never`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is defined.
  */
-export const guardDefined: GuardDefined = <Type>(
+export const guardDefined = <Type, Payload extends object = object>(
   value: Defined<Type>,
-  callback?: ResultCallback
-): value is Defined<Type> => isDefined(value, callback);
+  callback?: ResultCallback<Defined<Type>, Payload>,
+  payload?: Payload
+): value is Defined<Type> => isDefined(value, callback, payload);
diff --git a/src/guard/lib/guard-false.func.ts b/src/guard/lib/guard-false.func.ts
new file mode 100644
index 00000000..25a92f48
--- /dev/null
+++ b/src/guard/lib/guard-false.func.ts
@@ -0,0 +1,16 @@
+// Function.
+import { isFalse } from '../../is/lib/is-false.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guards the provided value to be `false`.
+ * @param value The value of `false` type to guard.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `boolean` type or an instance of `Boolean` equal to `false`.
+ */
+export const guardFalse = <Payload extends object>(
+  value: false,
+  callback?: ResultCallback<false, Payload>,
+  payload?: Payload
+): value is false => isFalse(value, callback, payload);
diff --git a/src/guard/lib/guard-function.func.ts b/src/guard/lib/guard-function.func.ts
index fb67961e..927dfd03 100644
--- a/src/guard/lib/guard-function.func.ts
+++ b/src/guard/lib/guard-function.func.ts
@@ -1,16 +1,16 @@
 // Function.
 import { isFunction } from '../../is/lib/is-function.func';
 // Type.
-import { GuardFunction } from '../type/guard-function.type';
-import { Func } from '../../type/func.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be a `Func` type.
- * @param value A `Func` type `value` to guard.
+ * Guards the value to be a `Function`.
+ * @param value The `function` of a generic type variable `Type` to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `Func`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `Function`.
  */
-export const guardFunction: GuardFunction = (
-  value: Func,
-  callback?: ResultCallback
-): value is Func => isFunction(value, callback);
+export const guardFunction = <Type extends Function, Payload extends object>(
+  value: Type,
+  callback?: ResultCallback<Type, Payload>,
+  payload?: Payload
+): value is Type => isFunction(value, callback, payload);
diff --git a/src/guard/lib/guard-instance.func.ts b/src/guard/lib/guard-instance.func.ts
index 8b7375ec..02d0e0a3 100644
--- a/src/guard/lib/guard-instance.func.ts
+++ b/src/guard/lib/guard-instance.func.ts
@@ -2,18 +2,21 @@
 import { isInstance } from '../../is/lib/is-instance.func';
 // Type.
 import { Constructor } from '../../type/constructor.type';
-import { GuardInstance } from '../type/guard-instance.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be an `object` of a generic `Obj` type and an instance of `Constructor` type.
- * @param value An `object`, by default of a generic `Obj` type detected from the `value`
- * to guard and check if it's a `constructor` instance.
- * @param constructor A class or function that specifies the type of the `constructor`.
+ * Guards the value to be an instance of the given `constructor`.
+ * @param value An `object` of a generic type variable `Obj` to guard and be compared with an instance of a given `constructor`.
+ * @param constructor A `class` or `function` that specifies the type of the `constructor`.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is an `instance` of a generic `Obj`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is an instance of a given `constructor`.
  */
-export const guardInstance: GuardInstance = <Obj extends object>(
+export const guardInstance = <
+  Obj extends object,
+  Payload extends object = object
+>(
   value: Obj,
   constructor: Constructor<Obj>,
-  callback?: ResultCallback
-): value is Obj => isInstance<Obj>(value, constructor, callback);
+  callback?: ResultCallback<Obj, { ctor: typeof constructor } & Payload>,
+  payload?: Payload
+): value is Obj => isInstance(value, constructor, callback, payload);
diff --git a/src/guard/lib/guard-is.object.ts b/src/guard/lib/guard-is.object.ts
index 8910e934..cdaf316d 100644
--- a/src/guard/lib/guard-is.object.ts
+++ b/src/guard/lib/guard-is.object.ts
@@ -3,40 +3,64 @@ import { guardArray } from './guard-array.func';
 import { guardBigInt } from './guard-big-int.func';
 import { guardBoolean } from './guard-boolean.func';
 import { guardClass } from './guard-class.func';
+import { guardDate } from './guard-date.func';
 import { guardDefined } from './guard-defined.func';
+import { guardFalse } from './guard-false.func';
 import { guardFunction } from './guard-function.func';
 import { guardInstance } from './guard-instance.func';
 import { guardKey } from './guard-key.func';
 import { guardNull } from './guard-null.func';
 import { guardNumber } from './guard-number.func';
+import { guardNumberBetween } from './guard-number-between.func';
 import { guardObject } from './guard-object.func';
 import { guardObjectKey } from './guard-object-key.func';
+import { guardObjectKeyIn } from './guard-object-key-in.func';
 import { guardObjectKeys } from './guard-object-keys.func';
+import { guardObjectKeysIn } from './guard-object-keys-in.func';
+import { guardObjectSomeKeys } from './guard-object-some-keys.func';
 import { guardPrimitive } from './guard-primitive.func';
+import { guardRegExp } from './guard-regexp.func';
 import { guardString } from './guard-string.func';
+import { guardStringIncludes } from './guard-string-includes.func';
+import { guardStringIncludesSome } from './guard-string-includes-some.func';
+import { guardStringLength } from './guard-string-length.func';
+import { guardStringLengthBetween } from './guard-string-length-between.func';
 import { guardSymbol } from './guard-symbol.func';
+import { guardTrue } from './guard-true.func';
 import { guardType } from './guard-type.func';
 import { guardUndefined } from './guard-undefined.func';
 // Interface.
 import { GuardIs } from '../interface/guard-is.interface';
 // `guardIs`.
-export const guardIs: GuardIs = {
+export const guardIs: GuardIs = Object.freeze({
   array: guardArray,
   bigint: guardBigInt,
   boolean: guardBoolean,
   class: guardClass,
+  date: guardDate,
   defined: guardDefined,
+  false: guardFalse,
   function: guardFunction,
   instance: guardInstance,
   key: guardKey,
   null: guardNull,
   number: guardNumber,
+  numberBetween: guardNumberBetween,
   object: guardObject,
   objectKey: guardObjectKey,
+  objectKeyIn: guardObjectKeyIn,
   objectKeys: guardObjectKeys,
+  objectKeysIn: guardObjectKeysIn,
+  objectSomeKeys: guardObjectSomeKeys,
   primitive: guardPrimitive,
+  regexp: guardRegExp,
   string: guardString,
+  stringIncludes: guardStringIncludes,
+  stringIncludesSome: guardStringIncludesSome,
+  stringLength: guardStringLength,
+  stringLengthBetween: guardStringLengthBetween,
   symbol: guardSymbol,
+  true: guardTrue,
   type: guardType,
   undefined: guardUndefined
-};
+});
diff --git a/src/guard/lib/guard-key.func.ts b/src/guard/lib/guard-key.func.ts
index d349a3ac..fed9ad5d 100644
--- a/src/guard/lib/guard-key.func.ts
+++ b/src/guard/lib/guard-key.func.ts
@@ -1,16 +1,16 @@
 // Function.
 import { isKey } from '../../is/lib/is-key.func';
 // Type.
-import { GuardKey } from '../type/guard-key.type';
-import { Key } from '../../type/key.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be one of the `string`, `number`, or `symbol`.
- * @param value A `Key` type `value` to guard.
+ * Guards the value to be one of `string`, `number`, or `symbol` type.
+ * @param value The value of generic type variable `Key` to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `Key`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `string`, `number`, or `symbol`.
  */
-export const guardKey: GuardKey = (
+export const guardKey = <Key extends PropertyKey, Payload extends object>(
   value: Key,
-  callback?: ResultCallback
-): value is Key => isKey(value, callback);
+  callback?: ResultCallback<Key, Payload>,
+  payload?: Payload
+): value is Key => isKey(value, callback, payload);
diff --git a/src/guard/lib/guard-null.func.ts b/src/guard/lib/guard-null.func.ts
index 089ef601..9d84a471 100644
--- a/src/guard/lib/guard-null.func.ts
+++ b/src/guard/lib/guard-null.func.ts
@@ -1,15 +1,16 @@
 // Function.
 import { isNull } from '../../is/lib/is-null.func';
 // Type.
-import { GuardNull } from '../type/guard-null.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be a `null`.
- * @param value A `null` type `value` to guard.
+ * Guards the value to be `null`.
+ * @param value The value of `null` type to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `null`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is `null`.
  */
-export const guardNull: GuardNull = (
+export const guardNull = <Payload extends object>(
   value: null,
-  callback?: ResultCallback
-): value is null => isNull(value, callback);
+  callback?: ResultCallback<null, Payload>,
+  payload?: Payload
+): value is null => isNull(value, callback, payload);
diff --git a/src/guard/lib/guard-number-between.func.ts b/src/guard/lib/guard-number-between.func.ts
new file mode 100644
index 00000000..99709515
--- /dev/null
+++ b/src/guard/lib/guard-number-between.func.ts
@@ -0,0 +1,29 @@
+// Function.
+import { isNumberBetween } from '../../is/lib/is-number-between.func';
+// Type.
+import { AnyNumber } from '../../type/any-number.type';
+import { NumberBetween } from '../../type/number-between.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guards the value to be `number` type or instance of `Number` between the specified range.
+ * @param value The value of a generic type variable `Type` to guard.
+ * @param min The **minimum** range of generic type variable `Min` for a given `value`.
+ * @param max The **maximum** range of generic type variable `Max` for a given `value`.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `number` type or an instance of `Number` between the
+ * specified range.
+ */
+export const guardNumberBetween = <
+  Type extends AnyNumber,
+  Min extends number,
+  Max extends number,
+  Payload extends object = object
+>(
+  value: Type,
+  min: Min,
+  max: Max,
+  callback?: ResultCallback<Type, { min: Min; max: Max } & Payload>,
+  payload?: Payload
+): value is NumberBetween<Min, Max, Type> =>
+  isNumberBetween(value, min, max, callback, payload);
diff --git a/src/guard/lib/guard-number.func.ts b/src/guard/lib/guard-number.func.ts
index 0b42c5a5..61093a7c 100644
--- a/src/guard/lib/guard-number.func.ts
+++ b/src/guard/lib/guard-number.func.ts
@@ -2,15 +2,19 @@
 import { isNumber } from '../../is/lib/is-number.func';
 // Type.
 import { AnyNumber } from '../../type/any-number.type';
-import { GuardNumber } from '../type/guard-number.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be any type of a number.
- * @param value An `AnyNumber` type `value`, by default of a generic `N` type detected from the `value` to guard.
+ * Guards the value to be a `number` of any type.
+ * @param value The value of generic type variable `Type` to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `number` type or `Number` object.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `number` type or an instance of `Number`.
  */
-export const guardNumber: GuardNumber = <N extends AnyNumber>(
-  value: N,
-  callback?: ResultCallback
-): value is N => isNumber(value, callback);
+export const guardNumber = <
+  Type extends AnyNumber,
+  Payload extends object = object
+>(
+  value: Type,
+  callback?: ResultCallback<Type, Payload>,
+  payload?: Payload
+): value is Type => isNumber(value, callback, payload);
diff --git a/src/guard/lib/guard-object-key-in.func.ts b/src/guard/lib/guard-object-key-in.func.ts
new file mode 100644
index 00000000..9022118b
--- /dev/null
+++ b/src/guard/lib/guard-object-key-in.func.ts
@@ -0,0 +1,24 @@
+// Function.
+import { isObjectKeyIn } from '../../is/lib/is-object-key-in.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guards the `value` to be an `object` of a generic type variable `Obj` that contains(or its prototype chain) the given `key`.
+ * @param value An `object` of a generic type variable `Obj`, by default of the type captured from itself that contains(or its prototype
+ * chain) the given `key`.
+ * @param key A key of generic type variable `Key` as the property name that the given `value` contains(or its prototype chain).
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is an `object` that contains(or its prototype chain) the given
+ * `key`.
+ */
+export const guardObjectKeyIn = <
+  Obj extends object,
+  Key extends keyof Obj,
+  Payload extends object = object
+>(
+  value: Obj,
+  key: Key,
+  callback?: ResultCallback<Obj, { key: typeof key } & Payload>,
+  payload?: Payload
+): value is Obj => isObjectKeyIn(value, key, callback, payload as any);
diff --git a/src/guard/lib/guard-object-key.func.ts b/src/guard/lib/guard-object-key.func.ts
index 3cd12301..059f4a67 100644
--- a/src/guard/lib/guard-object-key.func.ts
+++ b/src/guard/lib/guard-object-key.func.ts
@@ -1,17 +1,24 @@
 // Function.
 import { isObjectKey } from '../../is/lib/is-object-key.func';
 // Type.
-import { GuardObjectKey } from '../type/guard-object-key.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be an `object` of a generic `Obj` type that contains the `key`.
- * @param value An `object` of a generic `Obj` type that contains the `key`, by default of type detected from the `value` - to guard.
- * @param key A key of `Obj` or an array of keys of `Obj` type as the name of the property that the `value` contains.
+ * Guards the value to be an `object` of generic type variable `Obj` that contains the given `key`.
+ * @param value An `object` of a generic type variable `Obj`, by default of the type captured from itself that contains the given `key` to
+ * guard.
+ * @param key A key of generic type variable `Key` as the property name that the given `value` contains.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is an `object` of a generic `Obj` containing the `key`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is an `object` of generic type variable `Obj` that contains the
+ * given `key`.
  */
-export const guardObjectKey: GuardObjectKey = <Obj extends object>(
+export const guardObjectKey = <
+  Obj extends object,
+  Key extends keyof Obj,
+  Payload extends object = object
+>(
   value: Obj,
-  key: keyof Obj | (keyof Obj)[],
-  callback?: ResultCallback
-): value is Obj => isObjectKey<Obj>(value, key, callback);
+  key: Key,
+  callback?: ResultCallback<Obj, { key: typeof key } & Payload>,
+  payload?: Payload
+): value is Obj => isObjectKey(value, key, callback, payload as any);
diff --git a/src/guard/lib/guard-object-keys-in.func.ts b/src/guard/lib/guard-object-keys-in.func.ts
new file mode 100644
index 00000000..0807af7e
--- /dev/null
+++ b/src/guard/lib/guard-object-keys-in.func.ts
@@ -0,0 +1,24 @@
+// Function.
+import { isObjectKeysIn } from '../../is/lib/is-object-keys-in.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guards the value to be an `object` of a generic type variable `Obj` with specified keys in it(or its prototype chain).
+ * @param value An object of a generic type variable `Obj`, by default of the type captured from itself that contains(or its prototype
+ * chain) the given `keys` to guard.
+ * @param keys An `Array` of property keys to check whether the given `value` contains(or its prototype chain).
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is an `object` with specified `keys` in it(or its prototype
+ * chain).
+ */
+export const guardObjectKeysIn = <
+  Obj extends object,
+  Key extends keyof Obj,
+  Payload extends object = object
+>(
+  value: Obj,
+  keys: Key[],
+  callback?: ResultCallback<Obj, { keys: typeof keys } & Payload>,
+  payload?: Payload
+): value is Obj => isObjectKeysIn(value, keys, callback, payload as any);
diff --git a/src/guard/lib/guard-object-keys.func.ts b/src/guard/lib/guard-object-keys.func.ts
index a3139d79..f2793bd1 100644
--- a/src/guard/lib/guard-object-keys.func.ts
+++ b/src/guard/lib/guard-object-keys.func.ts
@@ -1,14 +1,23 @@
 // Function.
 import { isObjectKeys } from '../../is/lib/is-object-keys.func';
 // Type.
-import { GuardObjectKeys } from '../type/guard-object-keys.type';
+import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the value to be an `object` of a generic `Type` with some of its own specified `keys`.
- * @param value An object of a generic `Obj` type that contains the `keys`, by default of type detected from the `value` to guard.
- * @param keys A rest parameter single key of `Obj` or an array of keys of `Obj`, as the name of the property that the `value` contains.
- * @returns A `boolean` indicating whether or not the `value` is an `object` with some of its own specified `keys`.
+ * Guards the value to be an `object` of a generic type variable `Obj` with its specified `keys`.
+ * @param value An object of a generic type variable `Obj`, by default of the type captured from itself that contains the given `keys` to
+ * guard.
+ * @param keys An `Array` of property keys to check whether the given `value` contains.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is an `object` with its specified `keys`.
  */
-export const guardObjectKeys: GuardObjectKeys = <Obj extends object>(
+export const guardObjectKeys = <
+  Obj extends object,
+  Key extends keyof Obj,
+  Payload extends object = object
+>(
   value: Obj,
-  ...keys: (keyof Obj | Array<keyof Obj>)[]
-): value is Obj => isObjectKeys<Obj>(value, ...keys);
+  keys: Key[],
+  callback?: ResultCallback<Obj, { keys: typeof keys } & Payload>,
+  payload?: Payload
+): value is Obj => isObjectKeys(value, keys, callback, payload as any);
diff --git a/src/guard/lib/guard-object-some-keys.func.ts b/src/guard/lib/guard-object-some-keys.func.ts
new file mode 100644
index 00000000..89d6c5e7
--- /dev/null
+++ b/src/guard/lib/guard-object-some-keys.func.ts
@@ -0,0 +1,25 @@
+// Function.
+import { isObjectSomeKeys } from '../../is/lib/is-object-some-keys.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guards the value to be an `object` of a generic type variable `Obj` with some of its `keys` or some groups of its `keys`.
+ * @param value An object of a generic type variable `Obj`, by default of the type captured from itself that contains some or some of the
+ * groups of the given `keys`, to guard.
+ * @param keys An `Array` of property names or a two-dimensional array of property names to check if the given `value` contains some of
+ * them.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an `object` with some or some groups of the given
+ * `keys`.
+ * @angularpackage
+ */
+export const guardObjectSomeKeys = <
+  Obj extends object,
+  Payload extends object = object
+>(
+  value: Obj,
+  keys: (keyof Obj | Array<keyof Obj>)[],
+  callback?: ResultCallback<Obj, { keys: typeof keys } & Payload>,
+  payload?: Payload
+): value is Obj => isObjectSomeKeys(value, keys, callback, payload as any);
diff --git a/src/guard/lib/guard-object.func.ts b/src/guard/lib/guard-object.func.ts
index 440361c6..5c0055fd 100644
--- a/src/guard/lib/guard-object.func.ts
+++ b/src/guard/lib/guard-object.func.ts
@@ -1,15 +1,19 @@
 // Function.
 import { isObject } from '../../is/lib/is-object.func';
 // Type.
-import { GuardObject } from '../type/guard-object.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be an `object` of a generic `Obj` type.
- * @param value An `object` of a generic `Obj` type, by default of type detected from the `value` to guard.
+ * Guards the value to be an `object` of a generic type variable `Obj`.
+ * @param value An `object` of a generic type variable `Obj`, by default of the type captured from itself to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is an `object` of a generic `Obj`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an `object` of a generic type variable `Obj`.
  */
-export const guardObject: GuardObject = <Obj extends object>(
+export const guardObject = <
+  Obj extends object,
+  Payload extends object = object
+>(
   value: Obj,
-  callback?: ResultCallback
-): value is Obj => isObject<Obj>(value, callback);
+  callback?: ResultCallback<Obj, Payload>,
+  payload?: Payload
+): value is Obj => isObject(value, callback, payload);
diff --git a/src/guard/lib/guard-primitive.func.ts b/src/guard/lib/guard-primitive.func.ts
index 5ba343d6..8ca5b48b 100644
--- a/src/guard/lib/guard-primitive.func.ts
+++ b/src/guard/lib/guard-primitive.func.ts
@@ -1,19 +1,24 @@
 // Function.
 import { isPrimitive } from '../../is/lib/is-primitive.func';
 // Type.
-import { GuardPrimitive } from '../type/guard-primitive.type';
 import { Primitive } from '../../type/primitive.type';
 import { Primitives } from '../../type/primitives.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be the `Primitive` from a `type` of the `Primitives`.
- * @param value A `Primitive` type `value`, by default of a generic `Type` detected from the `value` to guard.
- * @param type A `string` type from the `Primitives` to check the `value`.
+ * Guards the value to be the `Primitive` type or the given `type` of the `Primitives`.
+ * @param value The value of a generic type variable `Type` constrained by the `Primitive`, by default of the type captured from itself to
+ * guard.
+ * @param type An optional specific type of `Primitives` to check the given value.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is the `Primitive` from the `type`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is the `Primitive` type or the given `type`.
  */
-export const guardPrimitive: GuardPrimitive = <Type extends Primitive>(
+export const guardPrimitive = <
+  Type extends Primitive,
+  Payload extends object = object
+>(
   value: Type,
-  type: Primitives,
-  callback?: ResultCallback
-): value is Type => isPrimitive<Type>(value, type, callback);
+  type?: Primitives,
+  callback?: ResultCallback<Type, Payload>,
+  payload?: Payload
+): value is Type => isPrimitive(value, type, callback, payload);
diff --git a/src/guard/lib/guard-regexp.func.ts b/src/guard/lib/guard-regexp.func.ts
new file mode 100644
index 00000000..f23b1f65
--- /dev/null
+++ b/src/guard/lib/guard-regexp.func.ts
@@ -0,0 +1,16 @@
+// Function.
+import { isRegExp } from '../../is/lib/is-regexp.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guards the value to be a `RegExp`.
+ * @param value Regular expression of generic type variable `Type` constrained by `RegExp` to guard.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return `value` is a `boolean` indicating whether the `value` is a `RegExp`.
+ */
+export const guardRegExp = <Type extends RegExp, Payload extends object>(
+  value: Type,
+  callback?: ResultCallback<Type, Payload>,
+  payload?: Payload
+): value is Type => isRegExp(value, callback, payload);
diff --git a/src/guard/lib/guard-string-includes-some.func.ts b/src/guard/lib/guard-string-includes-some.func.ts
new file mode 100644
index 00000000..bfbd3be9
--- /dev/null
+++ b/src/guard/lib/guard-string-includes-some.func.ts
@@ -0,0 +1,29 @@
+// Function.
+import { isStringIncludesSome } from '../../is/lib/is-string-includes-some.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { AnyString } from '../../type/any-string.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guards the value to be a `string` type or an instance of `String` that includes some of the specified words/sentences.
+ * @param value The value of a generic type variable `Type` constrained by the `AnyString`, by default of the type captured from itself to
+ * check against the `string` that contains some of the words/sentences from a given `includes`.
+ * @param includes An `Array` of `string` as words/sentences to be case-sensitive searched for within the given `value`.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `string` type or an instance of `String` that
+ * includes all of the specified words/sentences.
+ * @angularpackage
+ */
+export const guardStringIncludesSome = <
+  Type extends AnyString,
+  Payload extends object = object
+>(
+  value: Type,
+  includes: string[],
+  callback: ResultCallback<
+    Type,
+    { includes: typeof includes } & Payload
+  > = resultCallback,
+  payload?: Payload
+): value is Type => isStringIncludesSome(value, includes, callback, payload);
diff --git a/src/guard/lib/guard-string-includes.func.ts b/src/guard/lib/guard-string-includes.func.ts
new file mode 100644
index 00000000..b11bc594
--- /dev/null
+++ b/src/guard/lib/guard-string-includes.func.ts
@@ -0,0 +1,29 @@
+// Function.
+import { isStringIncludes } from '../../is/lib/is-string-includes.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { AnyString } from '../../type/any-string.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guards the value to be a `string` type or an instance of `String` that includes the specified words/sentences.
+ * @param value The value of a generic type variable `Type` constrained by the `AnyString`, by default of the type captured from itself to
+ * check against the `string` that contains words/sentences from a given `includes`.
+ * @param includes An `Array` of `string` as words/sentences to be case-sensitive searched for within the given `value`.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `string` type or an instance of `String` that
+ * includes the specified words/sentences.
+ * @angularpackage
+ */
+export const guardStringIncludes = <
+  Type extends AnyString,
+  Payload extends object = object
+>(
+  value: Type,
+  includes: string[],
+  callback: ResultCallback<
+    Type,
+    { includes: typeof includes } & Payload
+  > = resultCallback,
+  payload?: Payload
+): value is Type => isStringIncludes(value, includes, callback, payload);
diff --git a/src/guard/lib/guard-string-length-between.func.ts b/src/guard/lib/guard-string-length-between.func.ts
new file mode 100644
index 00000000..a19f9b0a
--- /dev/null
+++ b/src/guard/lib/guard-string-length-between.func.ts
@@ -0,0 +1,31 @@
+// Function.
+import { isStringLengthBetween } from '../../is';
+// Type.
+import { AnyString } from '../../type/any-string.type';
+import { ResultCallback } from '../../type/result-callback.type';
+import { StringOfLength } from '../../type/string-of-length.type';
+/**
+ * Guards the value to be `string` or `String` instance of a length between the specified range.
+ * @param value The value of a generic type variable `Type` constrained by `AnyString`, by default of the type captured from itself to
+ * guard.
+ * @param min The **minimum** length of generic type variable `Min` of a given `value`.
+ * @param max The **maximum** length of generic type variable `Max` of a given `value`.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `string` type or an instance of `String` of a length between
+ * the specified range.
+ * @angularpackage
+ */
+export const guardStringLengthBetween = <
+  Type extends AnyString,
+  Min extends number,
+  Max extends number,
+  Payload extends object = object
+>(
+  value: Type,
+  min: Min,
+  max: Max,
+  callback?: ResultCallback<Type, { min: Min; max: Max } & Payload>,
+  payload?: Payload
+): value is StringOfLength<Min, Max, Type> =>
+  isStringLengthBetween(value, min, max, callback, payload);
diff --git a/src/guard/lib/guard-string-length.func.ts b/src/guard/lib/guard-string-length.func.ts
new file mode 100644
index 00000000..5e17b14a
--- /dev/null
+++ b/src/guard/lib/guard-string-length.func.ts
@@ -0,0 +1,29 @@
+// Function.
+import { isStringLength } from '../../is';
+// Type.
+import { AnyString } from '../../type/any-string.type';
+import { ResultCallback } from '../../type/result-callback.type';
+import { StringOfLength } from '../../type/string-of-length.type';
+/**
+ * Guards the value to be `string` type or `String` instance of a specified length.
+ * @param value The value of a generic type variable `Type` constrained by `AnyString`, by default of the type captured from itself to
+ * guard.
+ * @param length The **length** of generic type variable `Length` of a given `value`.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `string` type or an instance of `String` of a specified
+ * `length`.
+ * @angularpackage
+ */
+export const guardStringLength = <
+  Type extends AnyString,
+  Length extends number,
+  Payload extends object = object
+>(
+  value: Type,
+  length: Length,
+  callback?: ResultCallback<Type, { length: Length } & Payload>,
+  payload?: Payload
+): value is StringOfLength<Length, Length, Type> =>
+  isStringLength(value, length, callback, payload);
+
diff --git a/src/guard/lib/guard-string.func.ts b/src/guard/lib/guard-string.func.ts
index ab924ff8..23114274 100644
--- a/src/guard/lib/guard-string.func.ts
+++ b/src/guard/lib/guard-string.func.ts
@@ -2,15 +2,20 @@
 import { isString } from '../../is/lib/is-string.func';
 // Type.
 import { AnyString } from '../../type/any-string.type';
-import { GuardString } from '../type/guard-string.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be any type of a string.
- * @param value An `AnyString` type `value`, by default of a generic `S` type detected from the `value` to guard.
+ * Guards the value to be `string` of any type.
+ * @param value The value of a generic type variable `Type` constrained by the `AnyString`, by default of the type captured from itself to
+ * guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `string` type or `String` object.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `string` type or an instance of `String`.
  */
-export const guardString: GuardString = <S extends AnyString>(
-  value: S,
-  callback?: ResultCallback
-): value is S => isString(value, callback);
+export const guardString = <
+  Type extends AnyString,
+  Payload extends object = object
+>(
+  value: Type,
+  callback?: ResultCallback<Type, Payload>,
+  payload?: Payload
+): value is Type => isString(value, callback, payload);
diff --git a/src/guard/lib/guard-symbol.func.ts b/src/guard/lib/guard-symbol.func.ts
index aa1913c1..89103a6b 100644
--- a/src/guard/lib/guard-symbol.func.ts
+++ b/src/guard/lib/guard-symbol.func.ts
@@ -1,15 +1,16 @@
 // Function.
 import { isSymbol } from '../../is/lib/is-symbol.func';
 // Type.
-import { GuardSymbol } from '../type/guard-symbol.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be a `symbol`.
- * @param value A `symbol` type `value` to guard.
+ * Guards the value to be a `symbol`.
+ * @param value A `symbol` type value to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `symbol`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `symbol`.
  */
-export const guardSymbol: GuardSymbol = (
+export const guardSymbol = <Payload extends object>(
   value: symbol,
-  callback?: ResultCallback
-): value is symbol => isSymbol(value, callback);
+  callback?: ResultCallback<symbol, Payload>,
+  payload?: Payload
+): value is symbol => isSymbol(value, callback, payload);
diff --git a/src/guard/lib/guard-true.func.ts b/src/guard/lib/guard-true.func.ts
new file mode 100644
index 00000000..6d187e01
--- /dev/null
+++ b/src/guard/lib/guard-true.func.ts
@@ -0,0 +1,17 @@
+// Function.
+import { isTrue } from '../../is/lib/is-true.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guards the value to be `true`.
+ * @param value The value of `true` type to guard.
+ * @param callback An optional `ResultCallback` function to handle the result before returns.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a `boolean` type or an instance of `Boolean` equal to `true`.
+ * @angularpackage
+ */
+export const guardTrue = <Payload extends object>(
+  value: true,
+  callback?: ResultCallback<true, Payload>,
+  payload?: Payload
+): value is true => isTrue(value, callback, payload);
diff --git a/src/guard/lib/guard-type.func.ts b/src/guard/lib/guard-type.func.ts
index 9c483852..ff89794d 100644
--- a/src/guard/lib/guard-type.func.ts
+++ b/src/guard/lib/guard-type.func.ts
@@ -1,20 +1,21 @@
 // Function.
 import { isType } from '../../is/lib/is-type.func';
 // Type.
-import { GuardType } from '../type/guard-type.type';
 import { ResultCallback } from '../../type/result-callback.type';
 import { Type } from '../../type/type.type';
 import { Types } from '../../type/types.type';
 /**
- * Guard the `value` to be the `Type` from a `type` of the `Types`.
- * @param value A `Type` `value`, by default of a generic `T` type detected from the `value` to guard with the `type`.
- * @param type A `string` or generic `Constructor` type from the `Types` to check the `value`.
+ * Guards the value to be a type of given `type`.
+ * @param value The value of a generic type variable `T` constrained by the `Type`, by default of the type captured from itself, to guard.
+ * @param type The value of `string` or `Constructor` type of the `Types` indicates against which type a given `value` is checked.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a type from the `Types`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is a type from a given `type`.
+ * @angularpackage
  */
-export const guardType: GuardType = <T extends Type>(
+export const guardType = <T extends Type, Payload extends object = object>(
   value: T,
   type: Types<T>,
-  callback?: ResultCallback
-): value is T => isType<T>(value, type, callback);
-
+  callback?: ResultCallback<T, Payload>,
+  payload?: Payload
+): value is T => isType(value, type, callback, payload);
diff --git a/src/guard/lib/guard-undefined.func.ts b/src/guard/lib/guard-undefined.func.ts
index 807ffca4..17f27da8 100644
--- a/src/guard/lib/guard-undefined.func.ts
+++ b/src/guard/lib/guard-undefined.func.ts
@@ -1,15 +1,17 @@
 // Function.
 import { isUndefined } from '../../is/lib/is-undefined.func';
 // Type.
-import { GuardUndefined } from '../type/guard-undefined.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be `undefined`.
- * @param value An `undefined` type `value` to guard.
+ * Guards the value to be `undefined`.
+ * @param value The value of an `undefined` type to guard.
  * @param callback An optional `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is `undefined`.
+ * @param payload Optional `object` of generic type variable `Payload` is assigned to the `payload` of the provided `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is `undefined`.
+ * @angularpackage
  */
-export const guardUndefined: GuardUndefined = (
+export const guardUndefined = <Payload extends object>(
   value: undefined,
-  callback?: ResultCallback
-): value is undefined => isUndefined(value, callback);
+  callback?: ResultCallback<undefined, Payload>,
+  payload?: Payload
+): value is undefined => isUndefined(value, callback, payload);
diff --git a/src/guard/lib/guard.object.ts b/src/guard/lib/guard.object.ts
index 2bf7dc5a..54ee33cf 100644
--- a/src/guard/lib/guard.object.ts
+++ b/src/guard/lib/guard.object.ts
@@ -1,8 +1,6 @@
-// Object.
+// Import: Object.
 import { guardIs } from './guard-is.object';
-// Interface.
+// Import: Interface.
 import { Guard } from '../interface/guard-interface';
-// `guard`
-export const guard: Guard = {
-  is: guardIs
-};
+// Export: `guard`
+export const guard: Guard = Object.freeze({ ...guardIs });
diff --git a/src/guard/test/guard-array.spec.ts b/src/guard/test/guard-array.spec.ts
index e94dc26d..c0626a6c 100644
--- a/src/guard/test/guard-array.spec.ts
+++ b/src/guard/test/guard-array.spec.ts
@@ -1,46 +1,53 @@
 // Function.
 import { guardArray } from '../lib/guard-array.func';
-// Constant.
+// Testing.
 import {
-  ARRAY_BIGINT,
-  ARRAY_BOOLEAN,
-  ARRAY_CLASS,
-  ARRAY_FUNCTION,
-  ARRAY_NULL,
-  ARRAY_NUMBER,
-  ARRAY_OBJECT_ONE,
-  ARRAY_OBJECT_TWO,
-  ARRAY_STRING,
-  ARRAY_SYMBOL_NUMBER,
-  ARRAY_SYMBOL_STRING,
-  ARRAY_UNDEFINED
-} from '../../testing/src/strict/array.const';
-import { Class } from '../../testing/src/strict/class.const';
-// Type.
-import { Func } from '../../type/func.type';
-// Interface.
-import { ObjectOne, ObjectTwo } from '../../testing/interface';
+  // Main.
+  Testing,
 
-describe(guardArray.name, () => {
-  // TRUE
-  it('is DEFINED', () => {
-    expect(guardArray).toBeDefined();
-  });
+  // Constants.
+  TESTING_ARRAY_BIGINT,
+  TESTING_ARRAY_BOOLEAN,
+  TESTING_ARRAY_CLASS,
+  TESTING_ARRAY_FUNCTION,
+  TESTING_ARRAY_NULL,
+  TESTING_ARRAY_NUMBER,
+  TESTING_ARRAY_OBJECT_ONE,
+  TESTING_ARRAY_STRING,
+  TESTING_ARRAY_SYMBOL_NUMBER,
+  TESTING_ARRAY_SYMBOL_STRING,
+  TESTING_ARRAY_UNDEFINED,
 
-  it('Array<bigint>', () => expect(guardArray<bigint>(ARRAY_BIGINT)).toBeTruthy());
-  it('Array<boolean>', () => expect(guardArray<boolean | Boolean>(ARRAY_BOOLEAN)).toBeTruthy());
-  it('Array<Class>', () => expect(guardArray<Class>(ARRAY_CLASS)).toBeTruthy());
-  it('Array<Func>', () => expect(guardArray<Func>(ARRAY_FUNCTION)).toBeTruthy());
-  it('Array<null>', () => expect(guardArray<null>(ARRAY_NULL)).toBeTruthy());
-  it('Array<number>', () => expect(guardArray<number | Number>(ARRAY_NUMBER)).toBeTruthy());
-  it('Array<ObjectOne> Array<ObjectTwo>', () => {
-    expect(guardArray<ObjectOne>(ARRAY_OBJECT_ONE)).toBeTruthy();
-    expect(guardArray<ObjectTwo>(ARRAY_OBJECT_TWO)).toBeTruthy();
-  });
-  it('Array<string>', () => expect(guardArray<string | String>(ARRAY_STRING)).toBeTruthy());
-  it('Array<symbol>', () => {
-    expect(guardArray<symbol>(ARRAY_SYMBOL_STRING)).toBeTruthy();
-    expect(guardArray<symbol>(ARRAY_SYMBOL_NUMBER)).toBeTruthy();
-  });
-  it('Array<undefined>', () => expect(guardArray<undefined | unknown>(ARRAY_UNDEFINED)).toBeTruthy());
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.array.describe,
+  tests.guard.array.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardArray.name, () => {
+  testing
+    // TRUE
+    .it('is DEFINED', () => expect(guardArray).toBeDefined())
+    .it('Array<bigint>', () => expect(guardArray<bigint>(TESTING_ARRAY_BIGINT)).toBeTruthy())
+    .it('Array<boolean>', () => expect(guardArray<boolean | Boolean>(TESTING_ARRAY_BOOLEAN)).toBeTruthy())
+    .it('Array<TestingClass>', () => expect(guardArray<TestingClass>(TESTING_ARRAY_CLASS)).toBeTruthy())
+    .it('Array<Func>', () => expect(guardArray<Function>(TESTING_ARRAY_FUNCTION)).toBeTruthy())
+    .it('Array<null>', () => expect(guardArray<null>(TESTING_ARRAY_NULL)).toBeTruthy())
+    .it('Array<number>', () => expect(guardArray<number | Number>(TESTING_ARRAY_NUMBER)).toBeTruthy())
+    .it('Array<ObjectOne> Array<ObjectTwo>', () => expect(guardArray(TESTING_ARRAY_OBJECT_ONE)).toBeTruthy())
+    .it('Array<string>', () => expect(guardArray<string | String>(TESTING_ARRAY_STRING)).toBeTruthy())
+    .it('Array<symbol>', () => {
+      expect(guardArray(TESTING_ARRAY_SYMBOL_STRING)).toBeTruthy();
+      expect(guardArray(TESTING_ARRAY_SYMBOL_NUMBER)).toBeTruthy();
+    })
+    .it('Array<undefined>', () => expect(guardArray<undefined | unknown>(TESTING_ARRAY_UNDEFINED)).toBeTruthy());
 });
diff --git a/src/guard/test/guard-bigint.spec.ts b/src/guard/test/guard-bigint.spec.ts
index fdb0e9b5..09b16cc7 100644
--- a/src/guard/test/guard-bigint.spec.ts
+++ b/src/guard/test/guard-bigint.spec.ts
@@ -1,30 +1,52 @@
 // Function.
 import { guardBigInt } from '../lib/guard-big-int.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/strict/big-int.const';
-import { TRUE } from '../../testing/src/strict/boolean.const';
+// Object.
+import { guard } from '../lib/guard.object';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardBigInt.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(guardBigInt).toBeDefined());
-
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      guardBigInt(BIGINT, (result: boolean, value: bigint) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(BIGINT);
-        return result;
-      });
-    });
-
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => {
-        it(`${BIGINT}`, () => expect(guardBigInt(BIGINT)).toBe(TRUE));
-        it(`${BIGINT_EXPECTATION}`, () => expect(guardBigInt(BIGINT_INSTANCE)).toBe(TRUE));
-      });
+  // Constant.
+  TESTING_BIGINT,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.bigint.describe,
+  tests.guard.bigint.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardBigInt.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(guardBigInt).toBeDefined())
+    // Checks ...
+    .describe(`guards`, () => {
+      testing
+      .it('with callback and payload', () => {
+        guardBigInt(TESTING_BIGINT, (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(TESTING_BIGINT);
+          if (payload) {
+            expect(payload.action).toEqual('action');
+            expect(payload.name).toEqual('name');
+            expect(payload.param).toEqual('param');
+          }
+          return result;
+        }, { action: 'action', name: 'name', param: 'param' });
+      })
+      // ... primitives.
+      .describe(`primitive`, () =>
+        testing.describe(`bigint`, () =>
+          testing
+            .it(`${TESTING_BIGINT}`, () => expect(guardBigInt(TESTING_BIGINT)).toBeTrue())
+            .it(`${TESTING_BIGINT}`, () => expect(guard.bigint(TESTING_BIGINT)).toBeTrue())
+          ));
     });
-  });
 });
diff --git a/src/guard/test/guard-boolean.spec.ts b/src/guard/test/guard-boolean.spec.ts
index 0f88da11..26bf101d 100644
--- a/src/guard/test/guard-boolean.spec.ts
+++ b/src/guard/test/guard-boolean.spec.ts
@@ -1,37 +1,70 @@
 // Function.
 import { guardBoolean } from '../lib/guard-boolean.func';
-// Constant.
-import { FALSE_EXPECTATION, TRUE, TRUE_EXPECTATION, FALSE, TRUE_INSTANCE, FALSE_INSTANCE } from '../../testing/src/strict/boolean.const';
+// Object.
+import { guard } from '../lib/guard.object';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardBoolean.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(guardBoolean).toBeDefined());
-
-  // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardBoolean(TRUE, (result: boolean, value: boolean) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(TRUE);
-        return result;
-      });
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // boolean
-      describe(`boolean`, () => {
-        it(`FALSE`, () => expect(guardBoolean(FALSE)).toBe(TRUE));
-        it(`TRUE`, () => expect(guardBoolean(TRUE)).toBe(TRUE));
+  // Constant.
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.boolean.describe,
+  tests.guard.boolean.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardBoolean.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(guardBoolean).toBeDefined())
+    // Checks ...
+    .describe(`guards`, () => {
+      testing
+      .it('with callback and payload', () => {
+        guardBoolean(TESTING_TRUE, (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(TESTING_TRUE);
+          if (payload) {
+            expect(payload.action).toEqual('action');
+            expect(payload.name).toEqual('name');
+            expect(payload.param).toEqual('param');
+          }
+          return result;
+        }, { action: 'action', name: 'name', param: 'param' });
+      })
+      // ... primitives.
+      .describe(`primitive`, () => {
+        // boolean
+        testing.describe(`boolean`, () => {
+          testing
+            .it(`FALSE`, () => expect(guardBoolean(TESTING_FALSE)).toBeTrue())
+            .it(`TRUE`, () => expect(guardBoolean(TESTING_TRUE)).toBeTrue())
+            .it(`FALSE`, () => expect(guard.boolean(TESTING_FALSE)).toBeTrue())
+            .it(`TRUE`, () => expect(guard.boolean(TESTING_TRUE)).toBeTrue());
+        });
+      })
+      // ... instance.
+      .describe(`instance`, () => {
+        // boolean
+        testing.describe(`boolean`, () => {
+          testing
+            .it(`${TESTING_TRUE_INSTANCE}`, () => expect(guardBoolean(TESTING_TRUE_INSTANCE)).toBeTrue())
+            .it(`${TESTING_FALSE_INSTANCE}`, () => expect(guardBoolean(TESTING_FALSE_INSTANCE)).toBeTrue())
+            .it(`${TESTING_FALSE_INSTANCE}`, () => expect(guard.boolean(TESTING_FALSE_INSTANCE)).toBeTrue())
+            .it(`${TESTING_TRUE_INSTANCE}`, () => expect(guard.boolean(TESTING_TRUE_INSTANCE)).toBeTrue());
+        });
       });
     });
-    // ... objective.
-    describe(`objective`, () => {
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE_EXPECTATION}`, () => expect(guardBoolean(TRUE_INSTANCE)).toBe(TRUE));
-        it(`${FALSE_EXPECTATION}`, () => expect(guardBoolean(FALSE_INSTANCE)).toBe(TRUE));
-      });
-    });
-
-  });
 });
diff --git a/src/guard/test/guard-class.spec.ts b/src/guard/test/guard-class.spec.ts
index bce40907..b844ee85 100644
--- a/src/guard/test/guard-class.spec.ts
+++ b/src/guard/test/guard-class.spec.ts
@@ -2,20 +2,48 @@
 import { guard } from '../lib/guard.object';
 // Function.
 import { guardClass } from '../lib/guard-class.func';
-// Constant.
-import { FALSE } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { Persons } from '../../testing/src/strict/class.const';
-import { TRUE } from '../../testing/src/strict/boolean.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardClass.name, () => {
-  it('is DEFINED', () => expect(guardClass).toBeDefined());
-  it(`Class`, () => {
-    expect(guardClass(Persons)).toBe(TRUE);
-    expect(guard.is.class(Persons)).toBe(TRUE);
-  });
-  it(`FUNCTION`, () => {
-    expect(guardClass(FUNCTION)).toBe(FALSE);
-    expect(guard.is.class(FUNCTION)).toBe(FALSE);
+  // Constant.
+  TESTING_FUNCTION,
+  TestingPerson
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.class.describe,
+  tests.guard.class.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardClass.name, () => {
+  testing
+  .it('is DEFINED', () => expect(guardClass).toBeDefined())
+  .it('with callback and payload', () => {
+    guardClass(TestingPerson, (result, value, payload) => {
+      expect(result).toBeTrue();
+      expect(value).toEqual(TestingPerson);
+      if (payload) {
+        expect(payload.action).toEqual('action');
+        expect(payload.name).toEqual('name');
+        expect(payload.param).toEqual('param');
+      }
+      return result;
+    }, { action: 'action', name: 'name', param: 'param' });
+  })
+  .it(`Class`, () => {
+    expect(guardClass(TestingPerson)).toBeTrue();
+    expect(guard.class(TestingPerson)).toBeTrue();
+  })
+  .it(`FUNCTION`, () => {
+    expect(guardClass(TESTING_FUNCTION)).toBeFalse();
+    expect(guard.class(TESTING_FUNCTION)).toBeFalse();
   });
 });
diff --git a/src/guard/test/guard-date.spec.ts b/src/guard/test/guard-date.spec.ts
new file mode 100644
index 00000000..d3c595a5
--- /dev/null
+++ b/src/guard/test/guard-date.spec.ts
@@ -0,0 +1,74 @@
+// Function.
+import { guardDate } from '../lib/guard-date.func';
+// Object.
+import { guard } from '../lib/guard.object';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_DATE,
+  TESTING_FUNCTION,
+
+  // Class.
+  TestingPerson
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.date.describe,
+  tests.guard.date.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardDate.name, () => {
+  let guardSpy: any;
+  testing
+    .it('is DEFINED', () => expect(guardDate).toBeDefined());
+
+  beforeEach(() => guardSpy = { ...{}, ...guard });
+  testing
+  .it('with callback and payload', () => {
+    guardDate(TESTING_DATE, (result, value, payload) => {
+      expect(result).toBeTrue();
+      expect(value).toEqual(TESTING_DATE);
+      if (payload) {
+        expect(payload.action).toEqual('action');
+        expect(payload.name).toEqual('name');
+        expect(payload.param).toEqual('param');
+      }
+      return result;
+    }, { action: 'action', name: 'name', param: 'param' });
+  })
+  .it(`called with ${TESTING_DATE}`, () => {
+      spyOn(guardSpy, 'date').withArgs(TESTING_DATE).and.returnValue(true);
+      guardSpy.date(TESTING_DATE);
+      expect(guardSpy.date).toHaveBeenCalled();
+  })
+  .it(`guard new Date()`, () => {
+    expect(guardDate(new Date('December 17, 1995 03:24:00'))).toBeTrue();
+    expect(guardDate(new Date('1995-12-17T03:24:00'))).toBeTrue();
+    expect(guardDate(new Date(1995, 11, 17))).toBeTrue();
+    expect(guardDate(new Date(1995, 11, 17, 3, 24, 0))).toBeTrue();
+    expect(guardDate(new Date(628021800000))).toBeTrue();
+    expect(guardDate(new Date(98, 1))).toBeTrue();
+    expect(guardDate(new Date(22, 1))).toBeTrue();
+
+    expect(guard.date(new Date('December 17, 1995 03:24:00'))).toBeTrue();
+    expect(guard.date(new Date('1995-12-17T03:24:00'))).toBeTrue();
+    expect(guard.date(new Date(1995, 11, 17))).toBeTrue();
+    expect(guard.date(new Date(1995, 11, 17, 3, 24, 0))).toBeTrue();
+    expect(guard.date(new Date(628021800000))).toBeTrue();
+    expect(guard.date(new Date(98, 1))).toBeTrue();
+    expect(guard.date(new Date(22, 1))).toBeTrue();
+  })
+  .it(`guard new Date() false`, () => {
+    expect(guardDate(new Date('invalid date'))).toBeFalse();
+    expect(guard.date(new Date('invalid date'))).toBeFalse();
+  });
+});
diff --git a/src/guard/test/guard-defined.spec.ts b/src/guard/test/guard-defined.spec.ts
index 540491a1..3b36ebee 100644
--- a/src/guard/test/guard-defined.spec.ts
+++ b/src/guard/test/guard-defined.spec.ts
@@ -1,21 +1,45 @@
 // Function.
 import { guardDefined } from '../lib/guard-defined.func';
-// Constant.
-import { STRING } from '../../testing/src/strict/string.const';
-import { TRUE } from '../../testing/src/strict/boolean.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardDefined.name, () => {
+  // Constant.
+  TESTING_STRING,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.defined.describe,
+  tests.guard.defined.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardDefined.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(guardDefined).toBeDefined());
+  .it('is DEFINED', () => expect(guardDefined).toBeDefined())
 
   // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardDefined(STRING, (result: boolean, value: any) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(STRING);
+  .describe(`guards`, () => {
+    testing
+    .it('with callback and payload', () => {
+      guardDefined(TESTING_STRING, (result, value, payload) => {
+        expect(result).toBeTrue();
+        expect(value).toEqual(TESTING_STRING);
+        if (payload) {
+          expect(payload.action).toEqual('action');
+          expect(payload.name).toEqual('name');
+          expect(payload.param).toEqual('param');
+        }
         return result;
-      });
-    });
+      }, { action: 'action', name: 'name', param: 'param' });
+    })
+    .it('undefined', () => expect(guardDefined(undefined as any)).toBeFalse());
   });
 });
diff --git a/src/guard/test/guard-false.spec.ts b/src/guard/test/guard-false.spec.ts
new file mode 100644
index 00000000..6167a991
--- /dev/null
+++ b/src/guard/test/guard-false.spec.ts
@@ -0,0 +1,59 @@
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_TRUE,
+  TESTING_FALSE
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+// Function.
+import { guardFalse } from '../lib/guard-false.func';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.false.describe,
+  tests.guard.false.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardFalse.name, () => {
+  testing
+  // Defined.
+  .it('is DEFINED', () => expect(guardFalse).toBeDefined())
+
+  // Checks ...
+  .describe(`guards`, () => {
+    testing
+    .it('with callback and payload', () => {
+      guardFalse(TESTING_FALSE, (result, value, payload) => {
+        expect(result).toBe(TESTING_TRUE);
+        expect(value).toBeFalse();
+        if (payload) {
+          expect(payload.action).toEqual('action');
+          expect(payload.name).toEqual('name');
+          expect(payload.param).toEqual('param');
+        }
+        return result;
+      }, { action: 'action', name: 'name', param: 'param' });
+    })
+
+    // ... primitives.
+    .describe(`primitive`, () =>
+      testing
+        .it(`${TESTING_FALSE}`, () => expect(guardFalse(TESTING_FALSE)).toBeTrue())
+        .it(`${TESTING_TRUE}`, () => expect(guardFalse(TESTING_TRUE as any)).toBeFalse())
+    )
+
+    // ... object.
+    .describe(`object`, () =>
+      testing
+        .it(`new Boolean(${TESTING_TRUE})`, () => expect(guardFalse(new Boolean(TESTING_TRUE) as any)).toBeFalse())
+        .it(`new Boolean(${TESTING_FALSE})`, () => expect(guardFalse(new Boolean(TESTING_FALSE) as any)).toBeTrue())
+    );
+  });
+});
diff --git a/src/guard/test/guard-function.spec.ts b/src/guard/test/guard-function.spec.ts
index 33a36cf6..55028f44 100644
--- a/src/guard/test/guard-function.spec.ts
+++ b/src/guard/test/guard-function.spec.ts
@@ -1,10 +1,42 @@
 // Function.
 import { guardFunction } from '../lib/guard-function.func';
-// Constant.
-import { FUNCTION } from '../../testing/src/function.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardFunction.name, () => {
+  // Constant.
+  TESTING_FUNCTION,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+// Function.
+import { guardFalse } from '../lib/guard-false.func';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.function.describe,
+  tests.guard.function.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardFalse.name, () => {
+  testing
   // TRUE
-  it('is DEFINED', () => expect(guardFunction).toBeDefined());
-  it(`function | Function`, () => expect(guardFunction(FUNCTION)).toBeTruthy());
+  .it('is DEFINED', () => expect(guardFunction).toBeDefined())
+  .it('with callback and payload', () => {
+    guardFunction(TESTING_FUNCTION, (result, value, payload) => {
+      expect(result).toBeTrue();
+      expect(value).toEqual(TESTING_FUNCTION);
+      if (payload) {
+        expect(payload.action).toEqual('action');
+        expect(payload.name).toEqual('name');
+        expect(payload.param).toEqual('param');
+      }
+      return result;
+    }, { action: 'action', name: 'name', param: 'param' });
+  })
+  .it(`function | Function`, () => expect(guardFunction(TESTING_FUNCTION)).toBeTrue());
 });
diff --git a/src/guard/test/guard-instance.spec.ts b/src/guard/test/guard-instance.spec.ts
index 87fad87b..09c26634 100644
--- a/src/guard/test/guard-instance.spec.ts
+++ b/src/guard/test/guard-instance.spec.ts
@@ -1,59 +1,88 @@
 // Function.
 import { guardInstance } from '../lib/guard-instance.func';
-// Constant.
-import { CLASS, Class, Persons } from '../../testing/src/strict/class.const';
-import { FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/strict/boolean.const';
-import { NUMBER } from '../../testing/src/strict/number.const';
-import { NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/strict/number.const';
-import { STRING } from '../../testing/src/strict/string.const';
-import { STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/strict/string.const';
-import { TRUE, TRUE_INSTANCE, FALSE_INSTANCE, FALSE } from '../../testing/src/strict/boolean.const';
-import { personFunctionConstructor } from '../../testing/src/strict/function.const';
-// Interface.
-import { Person } from '../../testing/interface/person.interface';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_CLASS,
+  TESTING_FALSE_INSTANCE,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_FUNCTION_CONSTRUCTOR_PERSON,
+  TESTING_PERSON,
+
+  // Class.
+  TestingClass,
+  TestingPerson,
+  TestingPersonShape
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.instance.describe,
+  tests.guard.instance.it
+);
 /**
  * Tests.
  */
-describe(guardInstance.name , () => {
-  const personInstance: Person = new (personFunctionConstructor as any)('First name', 'Sur name', 27);
-  const personsInstance: Persons = new Persons();
+testing.describe(guardInstance.name, () => {
+  const personInstance: TestingPersonShape = new (TESTING_FUNCTION_CONSTRUCTOR_PERSON as any)('First name', 'Sur name', 27);
+
+  testing
   // Defined.
-  it('is DEFINED', () => expect(guardInstance).toBeDefined());
+  .it('is DEFINED', () => expect(guardInstance).toBeDefined())
 
   // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardInstance(CLASS, Class, (result: boolean, value: Class) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(CLASS);
+  .describe(`guards`, () => {
+    testing
+    .it('callback', () => {
+      guardInstance(TESTING_CLASS, TestingClass, (result, value, payload) => {
+        expect(result).toBeTrue();
+        if (payload) {
+          expect(value).toEqual(TESTING_CLASS);
+        }
         return result;
       });
-    });
+    })
     // ... instance.
-    describe(`instance`, () => {
-      it(`CLASS`, () => expect(guardInstance(CLASS, Class)).toBe(TRUE));
-      it(`class Persons`, () => expect(guardInstance(personsInstance, Persons)).toBe(TRUE));
-      it(`function`, () => expect(guardInstance(personInstance, personFunctionConstructor as any)).toBe(TRUE));
-    });
+    .describe(`instance`, () => {
+      testing
+      .it(`CLASS`, () => expect(guardInstance(TESTING_CLASS, TestingClass)).toBeTrue())
+      .it(`class TestingPerson`, () => expect(guardInstance(TESTING_PERSON, TestingPerson)).toBeTrue())
+      .it(`function`, () => expect(guardInstance(personInstance, TESTING_FUNCTION_CONSTRUCTOR_PERSON as any)).toBeTrue());
+    })
 
     // ... primitives.
-    describe(`primitive`, () => {
+    .describe(`primitive`, () => {
+      testing
       // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE_EXPECTATION}`, () => expect(guardInstance(TRUE_INSTANCE, Boolean)).toBe(FALSE));
-        it(`${FALSE_EXPECTATION}`, () => expect(guardInstance(FALSE_INSTANCE, Boolean)).toBe(FALSE));
-      });
+      .describe(`boolean`, () => {
+        testing
+        .it(`${TESTING_TRUE_INSTANCE}`, () => expect(guardInstance(TESTING_TRUE_INSTANCE, Boolean)).toBeTrue())
+        .it(`${TESTING_FALSE_INSTANCE}`, () => expect(guardInstance(TESTING_FALSE_INSTANCE, Boolean)).toBeTrue());
+      })
 
       // number
-      describe(`number`, () => {
-        it(`Number(${NUMBER})`, () => expect(guardInstance(NUMBER_INSTANCE, Number)).toBe(FALSE));
-        it(`new Number(${NUMBER})`, () => expect(guardInstance(NUMBER_NEW_INSTANCE, Number)).toBe(FALSE));
-      });
+      .describe(`number`, () => {
+        testing
+        .it(`Number(${TESTING_NUMBER})`, () => expect(guardInstance(TESTING_NUMBER_CONSTRUCTOR, Number)).toBeFalse())
+        .it(`new Number(${TESTING_NUMBER})`, () => expect(guardInstance(TESTING_NUMBER_INSTANCE, Number)).toBeTrue());
+      })
 
       // string
-      describe(`string`, () => {
-        it(`String(${STRING})`, () => expect(guardInstance(STRING_INSTANCE, String)).toBe(FALSE));
-        it(`new String(${STRING})`, () => expect(guardInstance(STRING_NEW_INSTANCE, String)).toBe(FALSE));
+      .describe(`string`, () => {
+        it(`String(${TESTING_STRING})`, () => expect(guardInstance(TESTING_STRING_CONSTRUCTOR, String)).toBeFalse());
+        it(`new String(${TESTING_STRING})`, () => expect(guardInstance(TESTING_STRING_INSTANCE, String)).toBeTrue());
       });
     });
   });
diff --git a/src/guard/test/guard-key.spec.ts b/src/guard/test/guard-key.spec.ts
index 51f72f74..bc1f433f 100644
--- a/src/guard/test/guard-key.spec.ts
+++ b/src/guard/test/guard-key.spec.ts
@@ -1,37 +1,60 @@
 // Function.
 import { guardKey } from '../lib/guard-key.func';
-// Constant.
-import { NUMBER } from '../../testing/src/strict/number.const';
-import { STRING} from '../../testing/src/strict/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/strict/symbol.const';
-import { TRUE } from '../../testing/src/strict/boolean.const';
-// Type.
-import { Key } from '../../type/key.type';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardKey.name, () => {
+  // Constant.
+  TESTING_NUMBER,
+  TESTING_STRING,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.key.describe,
+  tests.guard.key.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardKey.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(guardKey).toBeDefined());
+  .it('is DEFINED', () => expect(guardKey).toBeDefined())
 
   // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardKey(STRING, (result: boolean, value: Key) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(STRING);
+  .describe(`guards`, () => {
+    testing
+    .it('with callback and payload', () => {
+      guardKey(TESTING_NUMBER, (result, value, payload) => {
+        expect(result).toBeTrue();
+        expect(value).toEqual(TESTING_NUMBER);
+        if (payload) {
+          expect(payload.action).toEqual('action');
+          expect(payload.name).toEqual('name');
+          expect(payload.param).toEqual('param');
+        }
         return result;
-      });
-    });
+      }, { action: 'action', name: 'name', param: 'param' });
+    })
 
     // ... primitives.
-    describe(`primitive`, () => {
+    .describe(`primitive`, () => {
+      testing
       // number
-      describe(`number`, () => it(`${NUMBER}`, () => expect(guardKey(NUMBER)).toBe(TRUE)));
+      .describe(`number`, () => it(`${TESTING_NUMBER}`, () => expect(guardKey(TESTING_NUMBER)).toBeTrue()))
       // string
-      describe(`string`, () => it(`${STRING}`, () => expect(guardKey(STRING)).toBe(TRUE)));
+      .describe(`string`, () => it(`${TESTING_STRING}`, () => expect(guardKey(TESTING_STRING)).toBeTrue()))
       // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(guardKey(SYMBOL_NUMBER)).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(guardKey(SYMBOL_STRING)).toBe(TRUE));
+      .describe(`symbol`, () => {
+        it(`Symbol(${TESTING_NUMBER})`, () => expect(guardKey(TESTING_SYMBOL_NUMBER)).toBeTrue());
+        it(`Symbol(${TESTING_STRING})`, () => expect(guardKey(TESTING_SYMBOL_STRING)).toBeTrue());
       });
     });
   });
diff --git a/src/guard/test/guard-null.spec.ts b/src/guard/test/guard-null.spec.ts
index 0dfbc78e..1640b51d 100644
--- a/src/guard/test/guard-null.spec.ts
+++ b/src/guard/test/guard-null.spec.ts
@@ -1,24 +1,48 @@
 // Function.
 import { guardNull } from '../lib/guard-null.func';
-// Constant.
-import { NULL } from '../../testing/src/strict/null.const';
-import { TRUE } from '../../testing/src/strict/boolean.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardNull.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(guardNull).toBeDefined());
+  // Constant.
+  TESTING_NULL,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.null.describe,
+  tests.guard.null.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardNull.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(guardNull).toBeDefined())
 
-  // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardNull(NULL, (result: boolean, value: null) => {
-        expect(result).toBe(TRUE);
-        expect(value).toBeNull();
-        return result;
-      });
-    });
+    // Checks ...
+    .describe(`guards`, () => {
+
+      testing
+      .it('with callback and payload', () => {
+        guardNull(TESTING_NULL, (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(TESTING_NULL);
+          if (payload) {
+            expect(payload.action).toEqual('action');
+            expect(payload.name).toEqual('name');
+            expect(payload.param).toEqual('param');
+          }
+          return result;
+        }, { action: 'action', name: 'name', param: 'param' });
+      })
 
-    // ... primitives.
-    describe(`primitive`, () => it(`${NULL}`, () => expect(guardNull(NULL)).toBe(TRUE)));
-  });
+      // ... primitives.
+      .describe(`primitive`, () => testing.it(`${TESTING_NULL}`, () => expect(guardNull(TESTING_NULL)).toBeTrue()));
+    });
 });
diff --git a/src/guard/test/guard-number-between.spec.ts b/src/guard/test/guard-number-between.spec.ts
new file mode 100644
index 00000000..940daff9
--- /dev/null
+++ b/src/guard/test/guard-number-between.spec.ts
@@ -0,0 +1,54 @@
+// Function.
+import { guardNumberBetween } from '../lib/guard-number-between.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_NUMBER,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.numberBetween.describe,
+  tests.guard.numberBetween.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardNumberBetween.name, () => {
+  testing
+  // Defined.
+  .it('is DEFINED', () => expect(guardNumberBetween).toBeDefined())
+
+  // Checks ...
+  .describe(`guards`, () => {
+    testing
+    .it('with callback and payload', () => {
+      guardNumberBetween(TESTING_NUMBER, 1, TESTING_NUMBER, (result, value, payload) => {
+        expect(result).toBeTrue();
+        expect(value).toEqual(TESTING_NUMBER);
+        if (payload) {
+          expect(payload.action).toEqual('action');
+          expect(payload.name).toEqual('name');
+          expect(payload.param).toEqual('param');
+        }
+        return result;
+      }, { action: 'action', name: 'name', param: 'param' });
+    })
+
+    // ... primitives.
+    .describe(`primitive`, () => {
+      testing
+      // number
+      .describe(`number`, () => {
+        testing
+        .it(`${TESTING_NUMBER}`, () => expect(guardNumberBetween(TESTING_NUMBER, 1, TESTING_NUMBER)).toBeTrue());
+      });
+    });
+  });
+});
diff --git a/src/guard/test/guard-number.spec.ts b/src/guard/test/guard-number.spec.ts
index 9a7ea63f..4aaa18bf 100644
--- a/src/guard/test/guard-number.spec.ts
+++ b/src/guard/test/guard-number.spec.ts
@@ -1,31 +1,59 @@
 // Function.
 import { guardNumber } from '../lib/guard-number.func';
-// Constant.
-import { NUMBER } from '../../testing/src/strict/number.const';
-import { TRUE } from '../../testing/src/strict/boolean.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardNumber.name, () => {
+  // Constant.
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.number.describe,
+  tests.guard.number.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardNumber.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(guardNumber).toBeDefined());
+  .it('is DEFINED', () => expect(guardNumber).toBeDefined())
 
   // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardNumber(NUMBER, (result: boolean, value: number) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(NUMBER);
+  .describe(`guards`, () => {
+    testing
+    .it('with callback and payload', () => {
+      guardNumber(TESTING_NUMBER, (result, value, payload) => {
+        expect(result).toBeTrue();
+        expect(value).toEqual(TESTING_NUMBER);
+        if (payload) {
+          expect(payload.action).toEqual('action');
+          expect(payload.name).toEqual('name');
+          expect(payload.param).toEqual('param');
+        }
         return result;
-      });
-    });
+      }, { action: 'action', name: 'name', param: 'param' });
+    })
 
     // ... primitives.
-    describe(`primitive`, () => {
+    .describe(`primitive`, () => {
+      testing
       // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(guardNumber(NUMBER)).toBe(TRUE));
-        // it(`Number(${NUMBER})`, () => expect(guardNumber(NUMBER_INSTANCE)).toBe(TRUE));
-        // it(`new Number(${NUMBER})`, () => expect(guardNumber(NUMBER_NEW_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`number`, () =>
+        testing
+          .it(`${TESTING_NUMBER}`, () => expect(guardNumber(TESTING_NUMBER)).toBeTrue())
+          .it(`${TESTING_NUMBER_CONSTRUCTOR}`, () => expect(guardNumber(TESTING_NUMBER_CONSTRUCTOR)).toBeTrue()))
+      // number object
+      .describe(`number object`, () =>
+        testing.it(`${TESTING_NUMBER_INSTANCE}`, () => expect(guardNumber(TESTING_NUMBER_INSTANCE)).toBeTrue()));
     });
   });
 });
diff --git a/src/guard/test/guard-object-key-in.spec.ts b/src/guard/test/guard-object-key-in.spec.ts
new file mode 100644
index 00000000..cb29df56
--- /dev/null
+++ b/src/guard/test/guard-object-key-in.spec.ts
@@ -0,0 +1,96 @@
+// Function.
+import { guardObjectKeyIn } from '../lib/guard-object-key-in.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_CLASS,
+  TESTING_NUMBER,
+  TESTING_OBJECT,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.objectKeyIn.describe,
+  tests.guard.objectKeyIn.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardObjectKeyIn.name, () => {
+  testing
+  // Defined.
+  .it('is DEFINED', () => expect(guardObjectKeyIn).toBeDefined())
+
+  // Checks ...
+  .describe(`guards`, () => {
+    testing
+    .it('with callback and payload', () => {
+      guardObjectKeyIn(TESTING_CLASS, 'firstName', (result, value, payload) => {
+        expect(result).toBeTrue();
+        expect(value).toEqual(TESTING_CLASS);
+        if (payload) {
+          expect(payload.action).toEqual('action');
+          expect(payload.name).toEqual('name');
+          expect(payload.param).toEqual('param');
+        }
+        return result;
+      }, { action: 'action', name: 'name', param: 'param' });
+    })
+
+    // ... instance.
+    .describe(`instance`, () => {
+      testing.describe(`CLASS`, () => {
+        testing
+        // number.
+        .it('has number key', () => {
+          expect(guardObjectKeyIn(TESTING_CLASS, 1030405027)).toBeTrue();
+          expect(guardObjectKeyIn(TESTING_CLASS, 5)).toBeTrue();
+        })
+
+        .it('finds getter number', () => expect(guardObjectKeyIn(TESTING_CLASS, TESTING_NUMBER)).toBeTrue())
+
+        // string.
+        .it('has string key', () => expect(guardObjectKeyIn(TESTING_CLASS, 'surname')).toBeTrue())
+
+        // symbol.
+        .it('finds getter symbol key', () => {
+          expect(guardObjectKeyIn(TESTING_CLASS, TESTING_SYMBOL_NUMBER)).toBeTrue();
+          expect(guardObjectKeyIn(TESTING_CLASS, TESTING_SYMBOL_STRING)).toBeTrue();
+        });
+      });
+    })
+
+    // ... objects.
+    .describe('object', () => {
+      testing.describe(`OBJECT_ONE`, () => {
+        testing
+          // number.
+          .it('has number key', () => {
+            expect(guardObjectKeyIn(TESTING_OBJECT, 1030405027)).toBeTrue();
+            expect(guardObjectKeyIn(TESTING_OBJECT, 5)).toBeTrue();
+            expect(guardObjectKeyIn(TESTING_OBJECT, TESTING_NUMBER)).toBeTrue();
+          })
+
+          // string.
+          .it('has string key', () => {
+            expect(guardObjectKeyIn(TESTING_OBJECT, 'key as string')).toBeTrue();
+            expect(guardObjectKeyIn(TESTING_OBJECT, 'x')).toBeTrue();
+          })
+
+          // symbol.
+          .it('has symbol key', () => {
+            expect(guardObjectKeyIn(TESTING_OBJECT, TESTING_NUMBER)).toBeTrue();
+            expect(guardObjectKeyIn(TESTING_OBJECT, TESTING_SYMBOL_STRING)).toBeTrue();
+          });
+      });
+    });
+  });
+});
diff --git a/src/guard/test/guard-object-key.spec.ts b/src/guard/test/guard-object-key.spec.ts
index 5cf0ea4b..6ce81630 100644
--- a/src/guard/test/guard-object-key.spec.ts
+++ b/src/guard/test/guard-object-key.spec.ts
@@ -1,69 +1,92 @@
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_NUMBER,
+  TESTING_OBJECT,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
 // Function.
 import { guardObjectKey } from '../lib/guard-object-key.func';
-// Constant.
-import { CLASS, TEST_CLASS, TestClass } from '../../testing/src/strict/class.const';
-import { NUMBER } from '../../testing/src/number.const';
-import { OBJECT_ONE } from '../../testing/src/object.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/strict/symbol.const';
-import { TRUE, FALSE } from '../../testing/src/strict/boolean.const';
-
-describe(guardObjectKey.name , () => {
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.objectKey.describe,
+  tests.guard.objectKey.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardObjectKey.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(guardObjectKey).toBeDefined());
+  .it('is DEFINED', () => expect(guardObjectKey).toBeDefined())
 
   // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardObjectKey<TestClass>(TEST_CLASS, ['firstName', 'surname'], (result: boolean, value: TestClass) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(TEST_CLASS);
+  .describe(`guards`, () => {
+    testing
+    .it('callback', () => {
+      guardObjectKey(TESTING_CLASS, 'firstName', (result, value, payload) => {
+        expect(result).toBeTrue();
+        if (payload) {
+          expect(value).toEqual(TESTING_CLASS);
+        }
         return result;
       });
-    });
+    })
 
     // ... instance.
-    describe(`instance`, () => {
-      describe(`CLASS`, () => {
+    .describe(`instance`, () => {
+      testing.describe(`CLASS`, () => {
         // number.
         it('has number key', () => {
-          expect(guardObjectKey(CLASS, 1030405027)).toBe(TRUE);
-          expect(guardObjectKey(CLASS, 5)).toBe(TRUE);
+          expect(guardObjectKey(TESTING_CLASS, 1030405027)).toBeTrue();
+          expect(guardObjectKey(TESTING_CLASS, 5)).toBeTrue();
         });
 
-        it('finds getter number', () => expect(guardObjectKey(CLASS, NUMBER)).toBe(FALSE));
+        it('finds getter number', () => expect(guardObjectKey(TESTING_CLASS, TESTING_NUMBER)).toBe(TESTING_FALSE));
 
         // string.
-        it('has string key', () => expect(guardObjectKey(CLASS, 'surname')).toBe(TRUE));
+        it('has string key', () => expect(guardObjectKey(TESTING_CLASS, 'surname')).toBeTrue());
 
         // symbol.
         it('finds getter symbol key', () => {
-          expect(guardObjectKey(CLASS, SYMBOL_NUMBER)).toBe(FALSE);
-          expect(guardObjectKey(CLASS, SYMBOL_STRING)).toBe(FALSE);
+          expect(guardObjectKey(TESTING_CLASS, TESTING_SYMBOL_NUMBER)).toBe(TESTING_FALSE);
+          expect(guardObjectKey(TESTING_CLASS, TESTING_SYMBOL_STRING)).toBe(TESTING_FALSE);
         });
       });
-    });
+    })
 
     // ... objects.
-    describe('object', () => {
-      describe(`OBJECT_ONE`, () => {
-        // number.
-        it('has number key', () => {
-          expect(guardObjectKey(OBJECT_ONE, 1030405027)).toBe(TRUE);
-          expect(guardObjectKey(OBJECT_ONE, 5)).toBe(TRUE);
-          expect(guardObjectKey(OBJECT_ONE, NUMBER)).toBe(TRUE);
-        });
+    .describe('object', () => {
+      testing.describe(`OBJECT_ONE`, () => {
+        testing
+          // number.
+          .it('has number key', () => {
+            expect(guardObjectKey(TESTING_OBJECT, 1030405027)).toBeTrue();
+            expect(guardObjectKey(TESTING_OBJECT, 5)).toBeTrue();
+            expect(guardObjectKey(TESTING_OBJECT, TESTING_NUMBER)).toBeTrue();
+          })
 
-        // string.
-        it('has string key', () => {
-          expect(guardObjectKey(OBJECT_ONE, 'key as string')).toBe(TRUE);
-          expect(guardObjectKey(OBJECT_ONE, 'x')).toBe(TRUE);
-        });
+          // string.
+          .it('has string key', () => {
+            expect(guardObjectKey(TESTING_OBJECT, 'key as string')).toBeTrue();
+            expect(guardObjectKey(TESTING_OBJECT, 'x')).toBeTrue();
+          })
 
-        // symbol.
-        it('has symbol key', () => {
-          expect(guardObjectKey(OBJECT_ONE, SYMBOL_NUMBER)).toBe(TRUE);
-          expect(guardObjectKey(OBJECT_ONE, SYMBOL_STRING)).toBe(TRUE);
-        });
+          // symbol.
+          .it('has symbol key', () => {
+            expect(guardObjectKey(TESTING_OBJECT, TESTING_NUMBER)).toBeTrue();
+            expect(guardObjectKey(TESTING_OBJECT, TESTING_SYMBOL_STRING)).toBeTrue();
+          });
       });
     });
   });
diff --git a/src/guard/test/guard-object-keys-in.spec.ts b/src/guard/test/guard-object-keys-in.spec.ts
new file mode 100644
index 00000000..8ebab17c
--- /dev/null
+++ b/src/guard/test/guard-object-keys-in.spec.ts
@@ -0,0 +1,108 @@
+// Function.
+import { guardObjectKeysIn } from '../lib/guard-object-keys-in.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_CLASS,
+  TESTING_NUMBER,
+  TESTING_OBJECT,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.objectKeysIn.describe,
+  tests.guard.objectKeysIn.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardObjectKeysIn.name, () => {
+  testing
+  // Defined.
+  .it('is DEFINED', () => expect(guardObjectKeysIn).toBeDefined())
+
+  // Checks ...
+  .describe(`guards`, () => {
+    testing
+    // ... instance.
+    .describe(`instance`, () => {
+      testing.describe(`TESTING_CLASS`, () => {
+        testing
+        // number.
+        .it('has number key', () => {
+          expect(guardObjectKeysIn(TESTING_CLASS, [1030405027])).toBeTrue();
+          expect(guardObjectKeysIn(TESTING_CLASS, [5])).toBeTrue();
+        })
+
+        .it('finds getter number', () => expect(guardObjectKeysIn(TESTING_CLASS, [TESTING_NUMBER])).toBeTrue())
+
+        // string.
+        .it('has string key', () => expect(guardObjectKeysIn(TESTING_CLASS, ['surname'])).toBeTrue())
+
+        // symbol.
+        .it('finds getter symbol key', () => {
+          expect(guardObjectKeysIn(TESTING_CLASS, [TESTING_SYMBOL_NUMBER])).toBeTrue();
+          expect(guardObjectKeysIn(TESTING_CLASS, [TESTING_SYMBOL_STRING])).toBeTrue();
+        });
+      });
+    })
+
+    // ... objects.
+    .describe('object', () => {
+      testing
+      .describe(`TESTING_OBJECT`, () => {
+        testing
+        // number.
+        .it('has number key', () => {
+          expect(guardObjectKeysIn(TESTING_OBJECT, [1030405027])).toBeTrue();
+          expect(guardObjectKeysIn(TESTING_OBJECT, [5])).toBeTrue();
+          expect(guardObjectKeysIn(TESTING_OBJECT, [TESTING_NUMBER])).toBeTrue();
+        })
+
+        // string.
+        .it('has string key', () => {
+          expect(guardObjectKeysIn(TESTING_OBJECT, ['key as string'])).toBeTrue();
+          expect(guardObjectKeysIn(TESTING_OBJECT, ['x'])).toBeTrue();
+        })
+
+        // symbol.
+        .it('has symbol key', () => {
+          expect(guardObjectKeysIn(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeTrue();
+          expect(guardObjectKeysIn(TESTING_OBJECT, [TESTING_SYMBOL_STRING])).toBeTrue();
+        });
+      });
+    })
+
+    .describe('object with some and every key', () => {
+      testing.describe(`TESTING_OBJECT`, () => {
+        testing
+        // number.
+        .it('has number key or any key', () => {
+          expect(guardObjectKeysIn(TESTING_OBJECT, [1030405027, 'key as string'])).toBeTrue();
+          expect(guardObjectKeysIn(TESTING_OBJECT, [5])).toBeTrue();
+          expect(guardObjectKeysIn(TESTING_OBJECT, [TESTING_NUMBER])).toBeTrue();
+        })
+
+        // string.
+        .it('has string key', () => {
+          expect(guardObjectKeysIn(TESTING_OBJECT, ['key as string'])).toBeTrue();
+          expect(guardObjectKeysIn(TESTING_OBJECT, ['x'])).toBeTrue();
+        })
+
+        // symbol.
+        .it('has symbol key', () => {
+          expect(guardObjectKeysIn(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER])).toBeTrue();
+          expect(guardObjectKeysIn(TESTING_OBJECT, [TESTING_SYMBOL_STRING])).toBeTrue();
+        });
+      });
+    });
+  });
+});
diff --git a/src/guard/test/guard-object-keys.spec.ts b/src/guard/test/guard-object-keys.spec.ts
index e99e4be4..43a6a77d 100644
--- a/src/guard/test/guard-object-keys.spec.ts
+++ b/src/guard/test/guard-object-keys.spec.ts
@@ -1,102 +1,106 @@
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_CLASS,
+  TESTING_NUMBER,
+  TESTING_OBJECT,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
 // Function.
 import { guardObjectKeys } from '../lib/guard-object-keys.func';
-// Constant.
-import { DATA_DESCRIPTOR, OBJECT_ONE, ACCESSOR_DESCRIPTOR } from '../../testing/src/object.const';
-// ... strict
-import { CLASS } from '../../testing/src/strict/class.const';
-import { NUMBER } from '../../testing/src/strict/number.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/strict/symbol.const';
-import { TRUE, FALSE } from '../../testing/src/strict/boolean.const';
-
-describe(guardObjectKeys.name , () => {
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.objectKeys.describe,
+  tests.guard.objectKeys.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardObjectKeys.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(guardObjectKeys).toBeDefined());
+  .it('is DEFINED', () => expect(guardObjectKeys).toBeDefined())
 
   // Checks ...
-  describe(`guards`, () => {
+  .describe(`guards`, () => {
+    testing
     // ... instance.
-    describe(`instance`, () => {
-      describe(`CLASS`, () => {
+    .describe(`instance`, () => {
+      testing.describe(`TESTING_CLASS`, () => {
+        testing
         // number.
-        it('has number key', () => {
-          expect(guardObjectKeys(CLASS, 1030405027)).toBe(TRUE);
-          expect(guardObjectKeys(CLASS, 5)).toBe(TRUE);
-        });
+        .it('has number key', () => {
+          expect(guardObjectKeys(TESTING_CLASS, [1030405027])).toBeTrue();
+          expect(guardObjectKeys(TESTING_CLASS, [5])).toBeTrue();
+        })
 
-        it('finds getter number', () => expect(guardObjectKeys(CLASS, NUMBER)).toBe(FALSE));
+        .it('finds getter number', () => expect(guardObjectKeys(TESTING_CLASS, [TESTING_NUMBER])).toBeFalse())
 
         // string.
-        it('has string key', () => expect(guardObjectKeys(CLASS, 'surname')).toBe(TRUE));
+        .it('has string key', () => expect(guardObjectKeys(TESTING_CLASS, ['surname'])).toBeTrue())
 
         // symbol.
-        it('finds getter symbol key', () => {
-          expect(guardObjectKeys(CLASS, SYMBOL_NUMBER)).toBe(FALSE);
-          expect(guardObjectKeys(CLASS, SYMBOL_STRING)).toBe(FALSE);
+        .it('finds getter symbol key', () => {
+          expect(guardObjectKeys(TESTING_CLASS, [TESTING_SYMBOL_NUMBER])).toBeFalse();
+          expect(guardObjectKeys(TESTING_CLASS, [TESTING_SYMBOL_STRING])).toBeFalse();
         });
       });
-    });
+    })
 
     // ... objects.
-    describe('object', () => {
-      describe(`descriptor`, () => {
-        it(`DATA_DESCRIPTOR`, () => {
-          // expect(guardObjectKeys(DATA_DESCRIPTOR, ['writable', 'value'], ['get', 'set'])).toBe(TRUE);
-          expect(guardObjectKeys(DATA_DESCRIPTOR, ['writable', 'value'])).toBe(TRUE);
-          expect(guardObjectKeys(DATA_DESCRIPTOR, 'writable', 'value')).toBe(TRUE);
-          // expect(guardObjectKeys(DATA_DESCRIPTOR, ['get', 'set'])).toBe(FALSE);
-          // expect(guardObjectKeys(DATA_DESCRIPTOR, 'get', 'set')).toBe(FALSE);
-          expect(guardObjectKeys(DATA_DESCRIPTOR, ['configurable', 'enumerable'], 'writable', 'value')).toBe(TRUE);
-          expect(guardObjectKeys(DATA_DESCRIPTOR, ['configurable', 'enumerable'], 'value')).toBe(TRUE);
-          expect(guardObjectKeys(DATA_DESCRIPTOR, ['configurable', 'enumerable'], 'writable')).toBe(TRUE);
-        });
-        it(`ACCESSOR_DESCRIPTOR`, () => {
-          // expect(guardObjectKeys(ACCESSOR_DESCRIPTOR, ['writable', 'value'], ['get', 'set'])).toBe(TRUE);
-          // expect(guardObjectKeys(ACCESSOR_DESCRIPTOR, ['configurable', 'enumerable'], 'writable', 'value')).toBe(TRUE);
-          expect(guardObjectKeys(ACCESSOR_DESCRIPTOR, ['configurable', 'enumerable'], 'get')).toBe(TRUE);
-          expect(guardObjectKeys(ACCESSOR_DESCRIPTOR, ['configurable', 'enumerable'], 'set')).toBe(TRUE);
-        });
-      });
-      describe(`OBJECT_ONE`, () => {
+    .describe('object', () => {
+      testing
+      .describe(`TESTING_OBJECT`, () => {
+        testing
         // number.
-        it('has number key', () => {
-          expect(guardObjectKeys(OBJECT_ONE, 1030405027)).toBe(TRUE);
-          expect(guardObjectKeys(OBJECT_ONE, 5)).toBe(TRUE);
-          expect(guardObjectKeys(OBJECT_ONE, NUMBER)).toBe(TRUE);
-        });
+        .it('has number key', () => {
+          expect(guardObjectKeys(TESTING_OBJECT, [1030405027])).toBeTrue();
+          expect(guardObjectKeys(TESTING_OBJECT, [5])).toBeTrue();
+          expect(guardObjectKeys(TESTING_OBJECT, [TESTING_NUMBER])).toBeTrue();
+        })
 
         // string.
-        it('has string key', () => {
-          expect(guardObjectKeys(OBJECT_ONE, 'key as string')).toBe(TRUE);
-          expect(guardObjectKeys(OBJECT_ONE, 'x')).toBe(TRUE);
-        });
+        .it('has string key', () => {
+          expect(guardObjectKeys(TESTING_OBJECT, ['key as string'])).toBeTrue();
+          expect(guardObjectKeys(TESTING_OBJECT, ['x'])).toBeTrue();
+        })
 
         // symbol.
-        it('has symbol key', () => {
-          expect(guardObjectKeys(OBJECT_ONE, SYMBOL_NUMBER, SYMBOL_STRING)).toBe(TRUE);
-          expect(guardObjectKeys(OBJECT_ONE, SYMBOL_STRING)).toBe(TRUE);
+        .it('has symbol key', () => {
+          expect(guardObjectKeys(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeTrue();
+          expect(guardObjectKeys(TESTING_OBJECT, [TESTING_SYMBOL_STRING])).toBeTrue();
         });
       });
-    });
+    })
 
-    describe('object with some and every key', () => {
-      describe(`OBJECT_ONE`, () => {
+    .describe('object with some and every key', () => {
+      testing.describe(`TESTING_OBJECT`, () => {
+        testing
         // number.
-        it('has number key or any key', () => {
-          expect(guardObjectKeys(OBJECT_ONE, 1030405027, 'key as string')).toBe(TRUE);
-          expect(guardObjectKeys(OBJECT_ONE, 5)).toBe(TRUE);
-          expect(guardObjectKeys(OBJECT_ONE, NUMBER)).toBe(TRUE);
-        });
+        .it('has number key or any key', () => {
+          expect(guardObjectKeys(TESTING_OBJECT, [1030405027, 'key as string'])).toBeTrue();
+          expect(guardObjectKeys(TESTING_OBJECT, [5])).toBeTrue();
+          expect(guardObjectKeys(TESTING_OBJECT, [TESTING_NUMBER])).toBeTrue();
+        })
 
         // string.
-        it('has string key', () => {
-          expect(guardObjectKeys(OBJECT_ONE, 'key as string')).toBe(TRUE);
-          expect(guardObjectKeys(OBJECT_ONE, 'x')).toBe(TRUE);
-        });
+        .it('has string key', () => {
+          expect(guardObjectKeys(TESTING_OBJECT, ['key as string'])).toBeTrue();
+          expect(guardObjectKeys(TESTING_OBJECT, ['x'])).toBeTrue();
+        })
 
         // symbol.
-        it('has symbol key', () => {
-          expect(guardObjectKeys(OBJECT_ONE, SYMBOL_NUMBER)).toBe(TRUE);
-          expect(guardObjectKeys(OBJECT_ONE, SYMBOL_STRING)).toBe(TRUE);
+        .it('has symbol key', () => {
+          expect(guardObjectKeys(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER])).toBeTrue();
+          expect(guardObjectKeys(TESTING_OBJECT, [TESTING_SYMBOL_STRING])).toBeTrue();
         });
       });
     });
diff --git a/src/guard/test/guard-object-some-keys.spec.ts b/src/guard/test/guard-object-some-keys.spec.ts
new file mode 100644
index 00000000..18ddf202
--- /dev/null
+++ b/src/guard/test/guard-object-some-keys.spec.ts
@@ -0,0 +1,110 @@
+// Function.
+import { guardObjectSomeKeys } from '../lib/guard-object-some-keys.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_CLASS,
+  TESTING_NUMBER,
+  TESTING_OBJECT,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.objectSomeKeys.describe,
+  tests.guard.objectSomeKeys.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardObjectSomeKeys.name, () => {
+  testing
+  // Defined.
+  .it('is DEFINED', () => expect(guardObjectSomeKeys).toBeDefined())
+
+  // Checks ...
+  .describe(`guards`, () => {
+    testing
+    // ... instance.
+    .describe(`instance`, () => {
+      testing
+      .describe(`TESTING_CLASS`, () => {
+        testing
+        // number.
+        .it('has number key', () => {
+          expect(guardObjectSomeKeys(TESTING_CLASS, [1030405027])).toBeTrue();
+          expect(guardObjectSomeKeys(TESTING_CLASS, [5])).toBeTrue();
+        })
+
+        .it('finds getter number', () => expect(guardObjectSomeKeys(TESTING_CLASS, [TESTING_NUMBER])).toBeFalse())
+
+        // string.
+        .it('has string key', () => expect(guardObjectSomeKeys(TESTING_CLASS, ['surname'])).toBeTrue())
+
+        // symbol.
+        .it('finds getter symbol key', () => {
+          expect(guardObjectSomeKeys(TESTING_CLASS, [TESTING_SYMBOL_NUMBER])).toBeFalse();
+          expect(guardObjectSomeKeys(TESTING_CLASS, [TESTING_SYMBOL_STRING])).toBeFalse();
+        });
+      });
+    })
+
+    // ... objects.
+    .describe('object', () => {
+      testing
+      .describe(`TESTING_OBJECT`, () => {
+        testing
+        // number.
+        .it('has number key', () => {
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [1030405027])).toBeTrue();
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [5])).toBeTrue();
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [TESTING_NUMBER])).toBeTrue();
+        })
+
+        // string.
+        .it('has string key', () => {
+          expect(guardObjectSomeKeys(TESTING_OBJECT, ['key as string'])).toBeTrue();
+          expect(guardObjectSomeKeys(TESTING_OBJECT, ['x'])).toBeTrue();
+        })
+
+        // symbol.
+        .it('has symbol key', () => {
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeTrue();
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [TESTING_SYMBOL_STRING])).toBeTrue();
+        });
+      });
+    })
+
+    .describe('object with some and every key', () => {
+      testing
+      .describe(`TESTING_OBJECT`, () => {
+        testing
+        // number.
+        .it('has number key or any key', () => {
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [1030405027, [5, TESTING_NUMBER]])).toBeTrue();
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [[TESTING_NUMBER], [5]])).toBeTrue();
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [TESTING_NUMBER])).toBeTrue();
+        })
+
+        // string.
+        .it('has string key', () => {
+          expect(guardObjectSomeKeys(TESTING_OBJECT, ['key as string', ['!@#$%^&*()Company', 'x']])).toBeTrue();
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [['x', '!@#$%^&*()Company'], 'key as string'])).toBeTrue();
+        })
+
+        // symbol.
+        .it('has symbol key', () => {
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING]])).toBeTrue();
+          expect(guardObjectSomeKeys(TESTING_OBJECT, [TESTING_SYMBOL_STRING])).toBeTrue();
+        });
+      });
+    });
+  });
+});
diff --git a/src/guard/test/guard-object.spec.ts b/src/guard/test/guard-object.spec.ts
index adfca354..9f45bd1a 100644
--- a/src/guard/test/guard-object.spec.ts
+++ b/src/guard/test/guard-object.spec.ts
@@ -1,31 +1,51 @@
 // Function.
 import { guardObject } from '../lib/guard-object.func';
-// Constant.
-import { CLASS } from '../../testing/src/strict/class.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { TRUE } from '../../testing/src/strict/boolean.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardObject.name, () => {
+  // Constant.
+  TESTING_CLASS,
+  TESTING_DATE,
+  TESTING_OBJECT,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.object.describe,
+  tests.guard.object.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardObject.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(guardObject).toBeDefined());
+  .it('is DEFINED', () => expect(guardObject).toBeDefined())
 
   // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardObject(OBJECT_ONE, (result: boolean, value: any) => {
-        expect(result).toBe(TRUE);
-        expect(OBJECT_ONE).toEqual(value);
+  .describe(`guards`, () => {
+    testing
+    .it('callback', () => {
+      guardObject(TESTING_OBJECT, (result, value, payload) => {
+        expect(result).toBeTrue();
+        if (payload) {
+          expect(value).toEqual(TESTING_OBJECT);
+        }
         return result;
       });
-    });
+    })
 
     // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(guardObject(CLASS)).toBe(TRUE));
-      it(`OBJECT_ONE`, () => expect(guardObject(OBJECT_ONE)).toBe(TRUE));
-      it(`OBJECT_TWO`, () => expect(guardObject(OBJECT_TWO)).toBe(TRUE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(guardObject(OBJECT_ONE_NEW)).toBe(TRUE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(guardObject(OBJECT_TWO_NEW)).toBe(TRUE));
+    .describe('object', () => {
+      testing
+        .it(`CLASS`, () => expect(guardObject(TESTING_CLASS)).toBeTrue())
+        .it(`OBJECT_ONE`, () => expect(guardObject(TESTING_OBJECT)).toBeTrue())
+        .it(`TESTING_DATE`, () => expect(guardObject(TESTING_DATE)).toBeTrue());
     });
   });
 });
diff --git a/src/guard/test/guard-primitive.spec.ts b/src/guard/test/guard-primitive.spec.ts
index 17907588..21776fc1 100644
--- a/src/guard/test/guard-primitive.spec.ts
+++ b/src/guard/test/guard-primitive.spec.ts
@@ -1,69 +1,88 @@
 // Function.
 import { guardPrimitive } from '../lib/guard-primitive.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/strict/big-int.const';
-import { FALSE, TRUE } from '../../testing/src/strict/boolean.const';
-import { NULL } from '../../testing/src/strict/null.const';
-import { NUMBER } from '../../testing/src/strict/number.const';
-import { STRING } from '../../testing/src/strict/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/strict/symbol.const';
-import { UNDEFINED } from '../../testing/src/strict/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardPrimitive.name, () => {
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_FALSE,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_STRING,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_UNDEFINED,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.primitive.describe,
+  tests.guard.primitive.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardPrimitive.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(guardPrimitive).toBeDefined());
+  .it('is DEFINED', () => expect(guardPrimitive).toBeDefined())
 
   // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardPrimitive<string>(STRING, 'string' , (result: boolean, value: string) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(STRING);
+  .describe(`guards`, () => {
+    testing
+    .it('callback', () => {
+      guardPrimitive<string>(TESTING_STRING, 'string' , (result, value, payload) => {
+        expect(result).toBeTrue();
+        if (payload) {
+          expect(value).toEqual(TESTING_STRING);
+        }
         return result;
       });
-    });
+    })
 
     // ... primitives.
-    describe(`primitive`, () => {
+    .describe(`primitive`, () => {
+      testing
       // bigint
-      describe(`bigint`, () => {
-        it(`${BIGINT}`, () => expect(guardPrimitive(BIGINT, 'bigint')).toBe(TRUE));
-        it(`${BIGINT_EXPECTATION}`, () => expect(guardPrimitive(BIGINT_INSTANCE, 'bigint')).toBe(TRUE));
-      });
+      .describe(`bigint`, () => it(`${TESTING_BIGINT}`, () => expect(guardPrimitive(TESTING_BIGINT, 'bigint')).toBeTrue()))
 
       // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(guardPrimitive(TRUE, 'boolean')).toBe(TRUE));
-        it(`${FALSE}`, () => expect(guardPrimitive(FALSE, 'boolean')).toBe(TRUE));
-        // it(`${TRUE_EXPECTATION}`, () => expect(guardPrimitive(TRUE_INSTANCE, 'boolean')).toBe(TRUE));
-        // it(`${FALSE_EXPECTATION}`, () => expect(guardPrimitive(FALSE_INSTANCE, 'boolean')).toBe(TRUE));
-      });
+      .describe(`boolean`, () => {
+        testing
+        .it(`${TESTING_TRUE}`, () => expect(guardPrimitive(TESTING_TRUE, 'boolean')).toBeTrue())
+        .it(`${TESTING_FALSE}`, () => expect(guardPrimitive(TESTING_FALSE, 'boolean')).toBeTrue());
+      })
 
       // null
-      it(`${NULL}`, () => expect(guardPrimitive(NULL, 'null')).toBe(TRUE));
+      .it(`${TESTING_NULL}`, () => expect(guardPrimitive(TESTING_NULL, 'null')).toBeTrue())
 
       // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(guardPrimitive(NUMBER, 'number')).toBe(TRUE));
-        // it(`Number(${NUMBER})`, () => expect(guardPrimitive(NUMBER_INSTANCE, 'number')).toBe(TRUE));
-        // it(`new Number(${NUMBER})`, () => expect(guardPrimitive(NUMBER_NEW_INSTANCE, 'number')).toBe(TRUE));
-      });
+      .describe(`number`, () => {
+        testing
+        .it(`${TESTING_NUMBER}`, () => expect(guardPrimitive(TESTING_NUMBER, 'number')).toBeTrue());
+      })
 
       // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(guardPrimitive(STRING, 'string')).toBe(TRUE));
-        // it(`String(${STRING})`, () => expect(guardPrimitive(STRING_INSTANCE, 'string')).toBe(TRUE));
-        // it(`new String(${STRING})`, () => expect(guardPrimitive(STRING_NEW_INSTANCE, 'string')).toBe(TRUE));
-      });
+      .describe(`string`, () => {
+        testing
+        .it(`${TESTING_STRING}`, () => expect(guardPrimitive(TESTING_STRING, 'string')).toBeTrue());
+      })
 
       // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(guardPrimitive(SYMBOL_NUMBER, 'symbol')).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(guardPrimitive(SYMBOL_STRING, 'symbol')).toBe(TRUE));
-      });
+      .describe(`symbol`, () => {
+        testing
+        .it(`Symbol(${TESTING_NUMBER})`, () => expect(guardPrimitive(TESTING_SYMBOL_NUMBER, 'symbol')).toBeTrue())
+        .it(`Symbol(${TESTING_STRING})`, () => expect(guardPrimitive(TESTING_SYMBOL_STRING, 'symbol')).toBeTrue());
+      })
 
       // undefined
-      it(`${UNDEFINED}`, () => expect(guardPrimitive(UNDEFINED, 'undefined')).toBe(TRUE));
+      .it(`${TESTING_UNDEFINED}`, () => expect(guardPrimitive(TESTING_UNDEFINED, 'undefined')).toBeTrue());
     });
   });
 });
diff --git a/src/guard/test/guard-regexp.spec.ts b/src/guard/test/guard-regexp.spec.ts
new file mode 100644
index 00000000..e4b2b860
--- /dev/null
+++ b/src/guard/test/guard-regexp.spec.ts
@@ -0,0 +1,52 @@
+// Function.
+import { guardRegExp } from '../lib/guard-regexp.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_TRUE,
+  TESTING_REGEXP
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.regexp.describe,
+  tests.guard.regexp.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardRegExp.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(guardRegExp).toBeDefined())
+
+    // Checks ...
+    .describe(`guards`, () => {
+      testing
+      .it('with callback and payload', () => {
+        guardRegExp(TESTING_REGEXP, (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(TESTING_REGEXP);
+          if (payload) {
+            expect(payload.action).toEqual('action');
+            expect(payload.name).toEqual('name');
+            expect(payload.param).toEqual('param');
+          }
+          return result;
+        }, { action: 'action', name: 'name', param: 'param' });
+      })
+
+      // ... primitives.
+      .describe(`primitive`, () => {
+        testing
+          // bigint
+          .describe(`RegExp`, () => it(`${TESTING_REGEXP}`, () => expect(guardRegExp(TESTING_REGEXP)).toBe(TESTING_TRUE)));
+      });
+    });
+});
diff --git a/src/guard/test/guard-string-includes-some.spec.ts b/src/guard/test/guard-string-includes-some.spec.ts
new file mode 100644
index 00000000..4988da11
--- /dev/null
+++ b/src/guard/test/guard-string-includes-some.spec.ts
@@ -0,0 +1,87 @@
+// Function.
+import { guardStringIncludesSome } from '../lib/guard-string-includes-some.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.stringIncludesSome.describe,
+  tests.is.stringIncludesSome.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardStringIncludesSome.name, () => {
+  const TESTING_STRING_LONG = `Lorem Ipsum is simply dummy text of the printing and typesetting industry.
+  Lorem Ipsum has been the industry's standard dummy text ever since the 1500s,
+  when an unknown printer took a galley of type and scrambled it to make a type specimen book.
+  It has survived not only five centuries, but also the leap into electronic typesetting,
+  remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset
+  sheets containing Lorem Ipsum passages, and more recently with desktop publishing software
+  like Aldus PageMaker including versions of Lorem Ipsum.`;
+
+  const TESTING_STRING_LONG_INSTANCE = new String(TESTING_STRING_LONG);
+
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(guardStringIncludesSome).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          guardStringIncludesSome(TESTING_STRING, ['Company'], (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_STRING);
+            }
+            return result;
+          });
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`TESTING_STRING, TESTING_STRING_LONG`, () => {
+                  expect(guardStringIncludesSome(TESTING_STRING, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeTrue();
+                    // No word exists.
+                  expect(guardStringIncludesSome(TESTING_STRING_LONG, [
+                    'no text',
+                    'no text is here'
+                  ])).toBeFalse();
+
+                  // Every word exists.
+                  expect(guardStringIncludesSome(TESTING_STRING_LONG_INSTANCE, [
+                    'Lorem',
+                    'unchanged',
+                    'versions',
+                    'only',
+                  ])).toBeTrue();
+
+                  // Some word exists.
+                  expect(guardStringIncludesSome(TESTING_STRING_LONG, [
+                    'Lorem',
+                    'unchanged',
+                    'versions',
+                    'only',
+                    'no text is here'
+                  ])).toBeTrue();
+                })
+                .it(`String(${TESTING_STRING})`, () =>
+                  expect(guardStringIncludesSome(TESTING_STRING_CONSTRUCTOR, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeTrue());
+            });
+        });
+    });
+});
\ No newline at end of file
diff --git a/src/guard/test/guard-string-includes.spec.ts b/src/guard/test/guard-string-includes.spec.ts
new file mode 100644
index 00000000..1f00f236
--- /dev/null
+++ b/src/guard/test/guard-string-includes.spec.ts
@@ -0,0 +1,88 @@
+// Function.
+import { guardStringIncludes } from '../lib/guard-string-includes.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.stringIncludes.describe,
+  tests.guard.stringIncludes.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardStringIncludes.name, () => {
+  const TESTING_STRING_LONG = `Lorem Ipsum is simply dummy text of the printing and typesetting industry.
+  Lorem Ipsum has been the industry's standard dummy text ever since the 1500s,
+  when an unknown printer took a galley of type and scrambled it to make a type specimen book.
+  It has survived not only five centuries, but also the leap into electronic typesetting,
+  remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset
+  sheets containing Lorem Ipsum passages, and more recently with desktop publishing software
+  like Aldus PageMaker including versions of Lorem Ipsum.`;
+
+  const TESTING_STRING_LONG_INSTANCE = new String(TESTING_STRING_LONG);
+
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(guardStringIncludes).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          guardStringIncludes(TESTING_STRING, ['Company'], (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_STRING);
+            }
+            return result;
+          });
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => {
+                  expect(guardStringIncludes(TESTING_STRING, ['Company'])).toBeTrue();
+                  expect(guardStringIncludes(TESTING_STRING, [TESTING_STRING, '!@#$%^&*()'])).toBeTrue();
+                    // No word exists.
+                  expect(guardStringIncludes(TESTING_STRING_LONG, [
+                    'no text',
+                    'no text is here'
+                  ])).toBeFalse();
+
+                  // Every word exists.
+                  expect(guardStringIncludes(TESTING_STRING_LONG_INSTANCE, [
+                    'Lorem',
+                    'unchanged',
+                    'versions',
+                    'only',
+                  ])).toBeTrue();
+
+                  // Some word exists.
+                  expect(guardStringIncludes(TESTING_STRING_LONG, [
+                    'Lorem',
+                    'unchanged',
+                    'versions',
+                    'only',
+                    'no text is here'
+                  ])).toBeFalse();
+                })
+                .it(`String(${TESTING_STRING})`, () =>
+                  expect(guardStringIncludes(TESTING_STRING_CONSTRUCTOR, [TESTING_STRING, '!@#$%^&*()'])).toBeTrue());
+            });
+        });
+    });
+});
diff --git a/src/guard/test/guard-string-length-between.spec.ts b/src/guard/test/guard-string-length-between.spec.ts
new file mode 100644
index 00000000..dd7661f6
--- /dev/null
+++ b/src/guard/test/guard-string-length-between.spec.ts
@@ -0,0 +1,86 @@
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+// Function.
+import { guardStringLengthBetween } from '../lib/guard-string-length-between.func';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.stringLengthBetween.describe,
+  tests.guard.stringLengthBetween.it
+);
+/**
+ * Tests.
+ */
+testing.describe(`guardStringLengthBetween()`, () => {
+  // Defined.
+  testing
+    .it('is DEFINED', () => expect(guardStringLengthBetween).toBeDefined())
+
+    // Checks ...
+    .describe(`guards`, () =>
+      testing
+        .it('with callback and payload', () => {
+          guardStringLengthBetween(TESTING_STRING, 3, 1000, (result, value, payload) => {
+            expect(result).toBeTrue();
+            expect(value).toEqual(TESTING_STRING);
+            if (payload) {
+              expect(payload.action).toEqual('action');
+              expect(payload.name).toEqual('name');
+              expect(payload.param).toEqual('param');
+            }
+            return result;
+          }, { action: 'action', name: 'name', param: 'param' });
+        })
+
+        // ... primitives.
+        .describe(`primitive`, () =>
+          testing
+            .describe(`string`, () =>
+              testing
+                .it(`${TESTING_STRING} minimum 3`, () =>
+                  expect(guardStringLengthBetween(TESTING_STRING, 3, 1000)).toBeTrue()
+                )
+                .it(`${TESTING_STRING} maximum 3`, () =>
+                  expect(guardStringLengthBetween(TESTING_STRING, 0, 3)).toBeFalse()
+                )
+            )
+            .it(`${TESTING_STRING} minimum 18`, () =>
+              expect(guardStringLengthBetween(TESTING_STRING, 18, 1000)).toBeFalse()
+            )
+            .it(`${TESTING_STRING} maximum 17`, () =>
+              expect(guardStringLengthBetween(TESTING_STRING, 0, 17)).toBeTrue()
+            )
+            .it(`${TESTING_STRING} minimum 5 maximum 21`, () =>
+              expect(guardStringLengthBetween(TESTING_STRING, 5, 21)).toBeTrue()
+            )
+        )
+    )
+    .describe(`String`, () =>
+      testing
+        .it(`new String(${TESTING_STRING}) minimum 3`, () =>
+          expect(guardStringLengthBetween(TESTING_STRING_INSTANCE, 3, 1000)).toBeTrue()
+        )
+        .it(`new String(${TESTING_STRING}) maximum 3`, () =>
+          expect(guardStringLengthBetween(TESTING_STRING_INSTANCE, 0, 3)).toBeFalse()
+        )
+        .it(`new String(${TESTING_STRING}) minimum 18`, () =>
+          expect(guardStringLengthBetween(TESTING_STRING_INSTANCE, 18, 1000)).toBeFalse()
+        )
+        .it(`new String(${TESTING_STRING}) maximum 17`, () =>
+          expect(guardStringLengthBetween(TESTING_STRING_INSTANCE, 0, 17)).toBeTrue()
+        )
+        .it(`new String(${TESTING_STRING}) minimum 5 maximum 21`, () =>
+          expect(guardStringLengthBetween(TESTING_STRING_INSTANCE, 5, 21)).toBeTrue()
+        )
+    );
+});
diff --git a/src/guard/test/guard-string-length.spec.ts b/src/guard/test/guard-string-length.spec.ts
new file mode 100644
index 00000000..c3167ad0
--- /dev/null
+++ b/src/guard/test/guard-string-length.spec.ts
@@ -0,0 +1,70 @@
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+// Function.
+import { guardStringLength } from '../lib/guard-string-length.func';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.stringLength.describe,
+  tests.guard.stringLength.it
+);
+/**
+ * Tests.
+ */
+testing.describe(`guardStringLength()`, () => {
+  // Defined.
+  testing
+    .it('is DEFINED', () => expect(guardStringLength).toBeDefined())
+
+    // Checks ...
+    .describe(`guards`, () =>
+      testing
+        .it('with callback and payload', () => {
+          guardStringLength(TESTING_STRING, 17, (result, value, payload) => {
+            expect(result).toBeTrue();
+            expect(value).toEqual(TESTING_STRING);
+            if (payload) {
+              expect(payload.action).toEqual('action');
+              expect(payload.name).toEqual('name');
+              expect(payload.param).toEqual('param');
+            }
+            return result;
+          }, { action: 'action', name: 'name', param: 'param' });
+        })
+
+        // ... primitives.
+        .describe(`primitive`, () =>
+          testing
+            .describe(`string`, () =>
+              testing
+                .it(`${TESTING_STRING}`, () =>
+                  expect(guardStringLength(TESTING_STRING, 17)).toBeTrue()
+                )
+                .it(`${TESTING_STRING}`, () =>
+                  expect(guardStringLength(TESTING_STRING, 16)).toBeFalse()
+                )
+                .it(`${TESTING_STRING}`, () =>
+                  expect(guardStringLength(TESTING_STRING, 18)).toBeFalse()
+                )
+            )
+        )
+    )
+    .describe(`String`, () =>
+      testing
+        .it(`new String(${TESTING_STRING})`, () =>
+          (expect(guardStringLength(TESTING_STRING_INSTANCE, 17)).toBeTrue(),
+          expect(guardStringLength(TESTING_STRING_INSTANCE, 16)).toBeFalse(),
+          expect(guardStringLength(TESTING_STRING_INSTANCE, 18)).toBeFalse())
+        )
+    );
+});
diff --git a/src/guard/test/guard-string.spec.ts b/src/guard/test/guard-string.spec.ts
index d4d99650..02a0837e 100644
--- a/src/guard/test/guard-string.spec.ts
+++ b/src/guard/test/guard-string.spec.ts
@@ -1,28 +1,61 @@
 // Function.
 import { guardString } from '../lib/guard-string.func';
-// Constant.
-import { STRING, STRING_NEW_INSTANCE } from '../../testing/src/strict/string.const';
-import { TRUE } from '../../testing/src/strict/boolean.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardString.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(guardString).toBeDefined());
+  // Constant.
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.string.describe,
+  tests.guard.string.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardString.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(guardString).toBeDefined())
 
-  // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardString(STRING, (result: boolean, value: string) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(STRING);
-        return result;
-      });
+    // Checks ...
+    .describe(`guards`, () => {
+      testing
+        .it('with callback and payload', () => {
+          guardString(TESTING_STRING, (result, value, payload) => {
+            expect(result).toBeTrue();
+            expect(value).toEqual(TESTING_STRING);
+            if (payload) {
+              expect(payload.action).toEqual('action');
+              expect(payload.name).toEqual('name');
+              expect(payload.param).toEqual('param');
+            }
+            return result;
+          }, { action: 'action', name: 'name', param: 'param' });
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            .describe(`string`, () =>
+              testing.it(`${TESTING_STRING}`, () =>
+                expect(guardString(TESTING_STRING)).toBeTrue()
+              )
+            )
+            .describe(`object`, () =>
+              testing.describe(`String`, () =>
+                testing.it(`new String(${TESTING_STRING})`, () =>
+                  expect(guardString(TESTING_STRING_INSTANCE)).toBeTrue()
+                )
+              )
+            );
+        });
     });
-    // ... primitives.
-    describe(`primitive`, () => {
-      describe(`string`, () => it(`${STRING}`, () => expect(guardString(STRING)).toBe(TRUE)));
-      describe(`object`, () => {
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(guardString(STRING_NEW_INSTANCE)).toBe(TRUE)));
-      })
-    });
-  });
 });
diff --git a/src/guard/test/guard-symbol.spec.ts b/src/guard/test/guard-symbol.spec.ts
index 1de87175..71a56e24 100644
--- a/src/guard/test/guard-symbol.spec.ts
+++ b/src/guard/test/guard-symbol.spec.ts
@@ -1,32 +1,59 @@
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_NUMBER,
+  TESTING_STRING,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
 // Function.
 import { guardSymbol } from '../lib/guard-symbol.func';
-// Constant.
-import { NUMBER } from '../../testing/src/strict/number.const';
-import { STRING } from '../../testing/src/strict/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/strict/symbol.const';
-import { TRUE } from '../../testing/src/strict/boolean.const';
-
-describe(guardSymbol.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(guardSymbol).toBeDefined());
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.symbol.describe,
+  tests.guard.symbol.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardSymbol.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(guardSymbol).toBeDefined())
 
-  // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardSymbol(SYMBOL_STRING, (result: boolean, value: symbol) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(SYMBOL_STRING);
-        return result;
-      });
-    });
+    // Checks ...
+    .describe(`guards`, () => {
+      testing
+      .it('with callback and payload', () => {
+        guardSymbol(TESTING_SYMBOL_STRING, (result, value, payload) => {
+          expect(result).toBeTrue();
+          expect(value).toEqual(TESTING_SYMBOL_STRING);
+          if (payload) {
+            expect(payload.action).toEqual('action');
+            expect(payload.name).toEqual('name');
+            expect(payload.param).toEqual('param');
+          }
+          return result;
+        }, { action: 'action', name: 'name', param: 'param' });
+      })
 
-    // ... primitives.
-    describe(`primitive`, () => {
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(guardSymbol(SYMBOL_NUMBER)).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(guardSymbol(SYMBOL_STRING)).toBe(TRUE));
+      // ... primitives.
+      .describe(`primitive`, () => {
+        testing
+          // symbol
+          .describe(`symbol`, () => {
+            testing
+              .it(`Symbol(${TESTING_NUMBER})`, () => expect(guardSymbol(TESTING_SYMBOL_NUMBER)).toBe(TESTING_TRUE))
+              .it(`Symbol(${TESTING_STRING})`, () => expect(guardSymbol(TESTING_SYMBOL_STRING)).toBe(TESTING_TRUE));
+          });
       });
     });
-  });
 });
diff --git a/src/guard/test/guard-true.spec.ts b/src/guard/test/guard-true.spec.ts
new file mode 100644
index 00000000..a514f934
--- /dev/null
+++ b/src/guard/test/guard-true.spec.ts
@@ -0,0 +1,55 @@
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_TRUE,
+  TESTING_FALSE
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+// Function.
+import { guardTrue } from '../lib/guard-true.func';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.true.describe,
+  tests.guard.true.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardTrue.name, () => {
+  testing
+  // Defined.
+  .it('is DEFINED', () => expect(guardTrue).toBeDefined())
+
+  // Checks ...
+  .describe(`guards`, () => {
+    testing.it('callback', () => {
+      guardTrue(TESTING_TRUE, (result, value, payload) => {
+        expect(result).toBe(TESTING_TRUE);
+        if (payload) {
+          expect(value).toBeTrue();
+        }
+        return result;
+      });
+    })
+
+    // ... primitives.
+    .describe(`primitive`, () =>
+      testing
+        .it(`${TESTING_TRUE}`, () => expect(guardTrue(TESTING_TRUE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_FALSE}`, () => expect(guardTrue(TESTING_FALSE as any)).toBe(TESTING_FALSE))
+    )
+
+    // ... object.
+    .describe(`object`, () =>
+      testing
+        .it(`new Boolean(${TESTING_TRUE})`, () => expect(guardTrue(new Boolean(TESTING_TRUE) as any)).toBe(TESTING_TRUE))
+        .it(`new Boolean(${TESTING_FALSE})`, () => expect(guardTrue(new Boolean(TESTING_FALSE) as any)).toBe(TESTING_FALSE))
+    );
+  });
+});
diff --git a/src/guard/test/guard-type.spec.ts b/src/guard/test/guard-type.spec.ts
new file mode 100644
index 00000000..92b54d7d
--- /dev/null
+++ b/src/guard/test/guard-type.spec.ts
@@ -0,0 +1,132 @@
+// Function.
+import { guardType } from '../lib/guard-type.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+// Function.
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(tests.is.type.describe, tests.is.type.it);
+/**
+ * Tests.
+ */
+testing.describe(guardType.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(guardType).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          guardType(TESTING_STRING, 'string', (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_STRING);
+            }
+            return result;
+          });
+          guardType(TESTING_NUMBER, 'number', (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_NUMBER);
+            }
+            return result;
+          });
+        })
+        // ... instance.
+        .describe(`instance`, () => testing.it(`Class`, () => expect(guardType<TestingClass>(TESTING_CLASS, TestingClass)).toBeTrue()))
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`${TESTING_FUNCTION}`, () => expect(guardType(TESTING_FUNCTION, 'function')).toBeTrue())
+            .it(`${TESTING_CLASS}`, () => expect(guardType(TestingClass, 'function')).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`CLASS`, () => expect(guardType(TESTING_CLASS, 'object')).toBeTrue())
+            .it(`TESTING_OBJECT`, () => expect(guardType(TESTING_OBJECT, 'object')).toBeTrue());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(guardType(TESTING_BIGINT, 'bigint')).toBeTrue()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(guardType(TESTING_TRUE, 'boolean')).toBeTrue())
+                .it(`${TESTING_FALSE}`, () => expect(guardType(TESTING_FALSE, 'boolean')).toBeTrue());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(guardType(TESTING_NULL, 'null')).toBeTrue())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(guardType(TESTING_NUMBER, 'number')).toBeTrue())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(guardType(TESTING_NUMBER_CONSTRUCTOR, 'number')).toBeTrue());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(guardType(TESTING_STRING, 'string')).toBeTrue())
+                .it(`String(${TESTING_STRING})`, () => expect(guardType(TESTING_STRING_CONSTRUCTOR, 'string')).toBeTrue());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(guardType(TESTING_SYMBOL_NUMBER, 'symbol')).toBeTrue())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(guardType(TESTING_SYMBOL_STRING, 'symbol')).toBeTrue());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(guardType(TESTING_UNDEFINED, 'undefined')).toBeTrue())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(guardType(TESTING_BIGINT, 'bigint')).toBeTrue()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(guardType(TESTING_TRUE_INSTANCE, 'boolean')).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(guardType(TESTING_FALSE_INSTANCE, 'boolean')).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(guardType(TESTING_NUMBER_INSTANCE, 'number')).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(guardType(TESTING_STRING_INSTANCE, 'string')).toBeFalse()));
+            });
+        });
+    });
+});
diff --git a/src/guard/test/guard-undefined.spec.ts b/src/guard/test/guard-undefined.spec.ts
index 90bb3ae7..a8efc6b5 100644
--- a/src/guard/test/guard-undefined.spec.ts
+++ b/src/guard/test/guard-undefined.spec.ts
@@ -1,23 +1,50 @@
 // Function.
 import { guardUndefined } from '../lib/guard-undefined.func';
-// Constant.
-import { TRUE } from '../../testing/src/strict/boolean.const';
-import { UNDEFINED } from '../../testing/src/strict/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(guardUndefined.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(guardUndefined).toBeDefined());
+  // Constant.
+  TESTING_UNDEFINED,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.guard.undefined.describe,
+  tests.guard.undefined.it
+);
+/**
+ * Tests.
+ */
+testing.describe(guardUndefined.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(guardUndefined).toBeDefined())
 
-  // Checks ...
-  describe(`guards`, () => {
-    it('callback', () => {
-      guardUndefined(UNDEFINED, (result: boolean, value: undefined) => {
-        expect(result).toBe(TRUE);
-        expect(value).toBeUndefined();
-        return result;
-      });
+    // Checks ...
+    .describe(`guards`, () => {
+      testing
+        .it('with callback and payload', () => {
+          guardUndefined(TESTING_UNDEFINED, (result, value, payload) => {
+            expect(result).toBeTrue();
+            expect(value).toEqual(TESTING_UNDEFINED);
+            if (payload) {
+              expect(payload.action).toEqual('action');
+              expect(payload.name).toEqual('name');
+              expect(payload.param).toEqual('param');
+            }
+            return result;
+          }, { action: 'action', name: 'name', param: 'param' });
+        })
+        // ... primitives.
+        .describe(`primitive`, () =>
+          testing.it(`${TESTING_UNDEFINED}`, () =>
+            expect(guardUndefined(TESTING_UNDEFINED)).toBeTrue()
+          )
+        );
     });
-    // ... primitives.
-    describe(`primitive`, () => it(`${UNDEFINED}`, () => expect(guardUndefined(UNDEFINED)).toBe(TRUE)));
-  });
 });
diff --git a/src/guard/test/guard.spec.ts b/src/guard/test/guard.spec.ts
index 258c2248..52af2893 100644
--- a/src/guard/test/guard.spec.ts
+++ b/src/guard/test/guard.spec.ts
@@ -1,24 +1,51 @@
 import { guard } from '../lib/guard.object';
-
-describe('`guard`', () => {
-   describe('DEFINED', () => {
-      it('guard', () => expect(guard).toBeDefined());
-      it('guard.is.array()', () => expect(guard.is.array).toBeDefined());
-      it('guard,is.boolean()', () => expect(guard.is.boolean).toBeDefined());
-      it('guard,is.class()', () => expect(guard.is.class).toBeDefined());
-      it('guard,is.defined()', () => expect(guard.is.defined).toBeDefined());
-      it('guard,is.function()', () => expect(guard.is.function).toBeDefined());
-      it('guard,is.instance()', () => expect(guard.is.instance).toBeDefined());
-      it('guard,is.key()', () => expect(guard.is.key).toBeDefined());
-      it('guard,is.null()', () => expect(guard.is.null).toBeDefined());
-      it('guard,is.number()', () => expect(guard.is.number).toBeDefined());
-      it('guard,is.object()', () => expect(guard.is.object).toBeDefined());
-      it('guard,is.objectKey()', () => expect(guard.is.objectKey).toBeDefined());
-      it('guard,is.objectKeys()', () => expect(guard.is.objectKeys).toBeDefined());
-      it('guard,is.primitive()', () => expect(guard.is.primitive).toBeDefined());
-      it('guard,is.string()', () => expect(guard.is.string).toBeDefined());
-      it('guard,is.symbol()', () => expect(guard.is.symbol).toBeDefined());
-      it('guard,is.type()', () => expect(guard.is.type).toBeDefined());
-      it('guard,is.undefined()', () => expect(guard.is.undefined).toBeDefined());
-   });
+// Testing.
+import {
+   // Main.
+   Testing,
+ } from '@angular-package/testing';
+ // Execute tests.
+import { tests } from '../../execute-tests';
+ /**
+  * Initialize testing.
+  */
+const testing = new Testing(
+   tests.object.guard.describe,
+   tests.object.guard.it
+ );
+ /**
+  * Tests.
+  */
+testing.describe(`guard`, () => {
+  testing
+  .describe('DEFINED', () => {
+    testing
+    .it('guard', () => expect(guard).toBeDefined())
+    .it('guard.array()', () => expect(guard.array).toBeDefined())
+    .it('guard.bigint()', () => expect(guard.bigint).toBeDefined())
+    .it('guard.boolean()', () => expect(guard.boolean).toBeDefined())
+    .it('guard.class()', () => expect(guard.class).toBeDefined())
+    .it('guard.defined()', () => expect(guard.defined).toBeDefined())
+    .it('guard.false()', () => expect(guard.false).toBeDefined())
+    .it('guard.function()', () => expect(guard.function).toBeDefined())
+    .it('guard.instance()', () => expect(guard.instance).toBeDefined())
+    .it('guard.key()', () => expect(guard.key).toBeDefined())
+    .it('guard.null()', () => expect(guard.null).toBeDefined())
+    .it('guard.number()', () => expect(guard.number).toBeDefined())
+    .it('guard.numberBetween()', () => expect(guard.numberBetween).toBeDefined())
+    .it('guard.object()', () => expect(guard.object).toBeDefined())
+    .it('guard.objectKey()', () => expect(guard.objectKey).toBeDefined())
+    .it('guard.objectKeyIn()', () => expect(guard.objectKeyIn).toBeDefined())
+    .it('guard.objectKeys()', () => expect(guard.objectKeys).toBeDefined())
+    .it('guard.objectKeysIn()', () => expect(guard.objectKeysIn).toBeDefined())
+    .it('guard.objectSomeKeys()', () => expect(guard.objectSomeKeys).toBeDefined())
+    .it('guard.primitive()', () => expect(guard.primitive).toBeDefined())
+    .it('guard.string()', () => expect(guard.string).toBeDefined())
+    .it('guard.stringIncludes()', () => expect(guard.stringIncludes).toBeDefined())
+    .it('guard.stringIncludesSome()', () => expect(guard.stringIncludesSome).toBeDefined())
+    .it('guard.symbol()', () => expect(guard.symbol).toBeDefined())
+    .it('guard.true()', () => expect(guard.true).toBeDefined())
+    .it('guard.type()', () => expect(guard.type).toBeDefined())
+    .it('guard.undefined()', () => expect(guard.undefined).toBeDefined());
+  });
 });
diff --git a/src/guard/type/guard-array.type.ts b/src/guard/type/guard-array.type.ts
deleted file mode 100644
index 9599fb30..00000000
--- a/src/guard/type/guard-array.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardArray = <Type>(value: Array<Type>, callback?: ResultCallback) => value is Array<Type>;
diff --git a/src/guard/type/guard-big-int.type.ts b/src/guard/type/guard-big-int.type.ts
deleted file mode 100644
index 25f520e3..00000000
--- a/src/guard/type/guard-big-int.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardBigInt = (value: bigint, callback?: ResultCallback) => value is bigint;
diff --git a/src/guard/type/guard-boolean.type.ts b/src/guard/type/guard-boolean.type.ts
deleted file mode 100644
index 853405e4..00000000
--- a/src/guard/type/guard-boolean.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { AnyBoolean } from '../../type/any-boolean.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardBoolean = <B extends AnyBoolean>(value: B, callback?: ResultCallback) => value is B;
diff --git a/src/guard/type/guard-class.type.ts b/src/guard/type/guard-class.type.ts
deleted file mode 100644
index 55baf65f..00000000
--- a/src/guard/type/guard-class.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardClass = <Class extends Function>(value: Class, callback?: ResultCallback) => value is Class;
diff --git a/src/guard/type/guard-defined.type.ts b/src/guard/type/guard-defined.type.ts
deleted file mode 100644
index c64b1774..00000000
--- a/src/guard/type/guard-defined.type.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-import { Defined } from '../../type/defined.type';
-import { ResultCallback } from '../../type/result-callback.type';
-/**
- * guardDefined function type.
- */
-export type GuardDefined = <Type>(value: Defined<Type>, callback?: ResultCallback) => value is Defined<Type>;
diff --git a/src/guard/type/guard-function.type.ts b/src/guard/type/guard-function.type.ts
deleted file mode 100644
index 82f6b8c0..00000000
--- a/src/guard/type/guard-function.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Func } from '../../type/func.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardFunction = (value: Func, callback?: ResultCallback) => value is Func;
diff --git a/src/guard/type/guard-instance.type.ts b/src/guard/type/guard-instance.type.ts
deleted file mode 100644
index 1ec6f4a0..00000000
--- a/src/guard/type/guard-instance.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Constructor } from '../../type/constructor.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardInstance = <Obj extends object>(value: Obj, constructor: Constructor<Obj>, callback?: ResultCallback) => value is Obj;
diff --git a/src/guard/type/guard-key.type.ts b/src/guard/type/guard-key.type.ts
deleted file mode 100644
index 5ae0b94f..00000000
--- a/src/guard/type/guard-key.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Key } from '../../type/key.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardKey = (value: Key, callback?: ResultCallback) => value is Key;
diff --git a/src/guard/type/guard-null.type.ts b/src/guard/type/guard-null.type.ts
deleted file mode 100644
index 75643565..00000000
--- a/src/guard/type/guard-null.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardNull = (value: null, callback?: ResultCallback) => value is null;
diff --git a/src/guard/type/guard-number.type.ts b/src/guard/type/guard-number.type.ts
deleted file mode 100644
index 45fafdb1..00000000
--- a/src/guard/type/guard-number.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-import { AnyNumber } from '../../type/any-number.type';
-export type GuardNumber = <N extends AnyNumber>(value: N, callback?: ResultCallback) => value is N;
diff --git a/src/guard/type/guard-object-key.type.ts b/src/guard/type/guard-object-key.type.ts
deleted file mode 100644
index 7cbab0d6..00000000
--- a/src/guard/type/guard-object-key.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardObjectKey = <Obj extends object>(value: Obj, key: keyof Obj | (keyof Obj)[], callback?: ResultCallback) => value is Obj;
-
-
diff --git a/src/guard/type/guard-object-keys.type.ts b/src/guard/type/guard-object-keys.type.ts
deleted file mode 100644
index adba7c44..00000000
--- a/src/guard/type/guard-object-keys.type.ts
+++ /dev/null
@@ -1 +0,0 @@
-export type GuardObjectKeys = <Obj extends object>(value: Obj, ...keys: (keyof Obj | Array<keyof Obj>)[]) => value is Obj;
diff --git a/src/guard/type/guard-object.type.ts b/src/guard/type/guard-object.type.ts
deleted file mode 100644
index 761a5e83..00000000
--- a/src/guard/type/guard-object.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardObject = <Obj extends object>(value: Obj, callback?: ResultCallback) => value is Obj;
diff --git a/src/guard/type/guard-primitive.type.ts b/src/guard/type/guard-primitive.type.ts
deleted file mode 100644
index fc0a2467..00000000
--- a/src/guard/type/guard-primitive.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { Primitive } from '../../type/primitive.type';
-import { Primitives } from '../../type/primitives.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardPrimitive = <T extends Primitive>(value: T, type: Primitives, callback?: ResultCallback) => value is T;
diff --git a/src/guard/type/guard-string.type.ts b/src/guard/type/guard-string.type.ts
deleted file mode 100644
index b9bc2f3e..00000000
--- a/src/guard/type/guard-string.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { AnyString } from '../../type/any-string.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardString = <S extends AnyString>(value: S, callback?: ResultCallback) => value is S;
diff --git a/src/guard/type/guard-symbol.type.ts b/src/guard/type/guard-symbol.type.ts
deleted file mode 100644
index 8cd97295..00000000
--- a/src/guard/type/guard-symbol.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardSymbol = (value: symbol, callback?: ResultCallback) => value is symbol;
diff --git a/src/guard/type/guard-type.type.ts b/src/guard/type/guard-type.type.ts
deleted file mode 100644
index 6563c07a..00000000
--- a/src/guard/type/guard-type.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-import { Types } from '../../type/types.type';
-import { Type } from '../../type/type.type';
-export type GuardType = <T extends Type>(value: T, type: Types<T>, callback?: ResultCallback) => value is T;
diff --git a/src/guard/type/guard-undefined.type.ts b/src/guard/type/guard-undefined.type.ts
deleted file mode 100644
index 875793e2..00000000
--- a/src/guard/type/guard-undefined.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type GuardUndefined = (value: undefined, callback?: ResultCallback) => value is undefined;
diff --git a/src/interface/index.ts b/src/interface/index.ts
new file mode 100644
index 00000000..19fd851f
--- /dev/null
+++ b/src/interface/index.ts
@@ -0,0 +1 @@
+export { MinMax } from './min-max.interface';
diff --git a/src/interface/min-max.interface.ts b/src/interface/min-max.interface.ts
new file mode 100644
index 00000000..4e0b2098
--- /dev/null
+++ b/src/interface/min-max.interface.ts
@@ -0,0 +1,14 @@
+/**
+ * A generic type `MinMax` that takes generic type variables `Min` and `Max` represents the range between minimum and maximum.
+ */
+export interface MinMax<Min extends number, Max extends number> {
+  /**
+   * The minimum value of a generic type variable `Min` constrained by a `number` type.
+   */
+  min?: Min;
+
+  /**
+   * The maximum value of a generic type variable `Max` constrained by a `number` type.
+   */
+  max?: Max;
+}
diff --git a/src/is/index.ts b/src/is/index.ts
index 48e76ab3..bbbfdcfc 100644
--- a/src/is/index.ts
+++ b/src/is/index.ts
@@ -5,23 +5,35 @@ export { isBoolean } from './lib/is-boolean.func';
 export { isBooleanObject } from './lib/is-boolean-object.func';
 export { isBooleanType } from './lib/is-boolean-type.func';
 export { isClass } from './lib/is-class.func';
+export { isDate } from './lib/is-date.func'; // From 4.2.0
 export { isDefined } from './lib/is-defined.func';
+export { isFalse } from './lib/is-false.func'; // From 4.2.0
 export { isFunction } from './lib/is-function.func';
 export { isInstance } from './lib/is-instance.func';
 export { isKey } from './lib/is-key.func';
 export { isNull } from './lib/is-null.func';
 export { isNumber } from './lib/is-number.func';
+export { isNumberBetween } from './lib/is-number-between.func'; // From 4.2.0
 export { isNumberObject } from './lib/is-number-object.func';
 export { isNumberType } from './lib/is-number-type.func';
 export { isObject } from './lib/is-object.func';
 export { isObjectKey } from './lib/is-object-key.func';
 export { isObjectKeyIn } from './lib/is-object-key-in.func';
 export { isObjectKeys } from './lib/is-object-keys.func';
+export { isObjectKeysIn } from './lib/is-object-keys-in.func';
+export { isObjectSomeKeys } from './lib/is-object-some-keys.func';
+export { isParam } from './lib/is-param.decorator';
 export { isPrimitive } from './lib/is-primitive.func';
+export { isRegExp } from './lib/is-regexp.func'; // From 4.2.0
 export { isString } from './lib/is-string.func';
+export { isStringIncludes } from './lib/is-string-includes.func';
+export { isStringIncludesSome } from './lib/is-string-includes-some.func';
+export { isStringLength } from './lib/is-string-length.func'; // From 4.2.0
+export { isStringLengthBetween } from './lib/is-string-length-between.func'; // From 5.0.0
 export { isStringObject } from './lib/is-string-object.func';
 export { isStringType } from './lib/is-string-type.func';
 export { isSymbol } from './lib/is-symbol.func';
+export { isTrue } from './lib/is-true.func'; // From 4.2.0
 export { isType } from './lib/is-type.func';
 export { isUndefined } from './lib/is-undefined.func';
 // `is` object.
diff --git a/src/is/interface/is.interface.ts b/src/is/interface/is.interface.ts
index a62c4db8..3cc7815a 100644
--- a/src/is/interface/is.interface.ts
+++ b/src/is/interface/is.interface.ts
@@ -1,58 +1,246 @@
-import { IsArray } from '../type/is-array.type';
-import { IsBigInt } from '../type/is-big-int.type';
-import { IsBoolean } from '../type/is-boolean.type';
-import { IsBooleanObject } from '../type/is-boolean-object.type';
-import { IsBooleanType } from '../type/is-boolean-type.type';
-import { IsClass } from '../type/is-class.type';
-import { IsDefined } from '../type/is-defined.type';
-import { IsFunction } from '../type/is-function.type';
-import { IsInstance } from '../type/is-instance.type';
-import { IsKey } from '../type/is-key.type';
+// Function.
+import { isArray } from '../lib/is-array.func';
+import { isBigInt } from '../lib/is-big-int.func';
+import { isBoolean } from '../lib/is-boolean.func';
+import { isBooleanObject } from '../lib/is-boolean-object.func';
+import { isBooleanType } from '../lib/is-boolean-type.func';
+import { isClass } from '../lib/is-class.func';
+import { isDate } from '../lib/is-date.func';
+import { isDefined } from '../lib/is-defined.func';
+import { isFalse } from '../lib/is-false.func';
+import { isFunction } from '../lib/is-function.func';
+import { isInstance } from '../lib/is-instance.func';
+import { isKey } from '../lib/is-key.func';
+import { isNull } from '../lib/is-null.func';
+import { isNumber } from '../lib/is-number.func';
+import { isNumberBetween } from '../lib/is-number-between.func';
+import { isNumberObject } from '../lib/is-number-object.func';
+import { isNumberType } from '../lib/is-number-type.func';
+import { isObject } from '../lib/is-object.func';
+import { isObjectKey } from '../lib/is-object-key.func';
+import { isObjectKeyIn } from '../lib/is-object-key-in.func';
+import { isObjectKeys } from '../lib/is-object-keys.func';
+import { isObjectKeysIn } from '../lib/is-object-keys-in.func';
+import { isObjectSomeKeys } from '../lib/is-object-some-keys.func';
+import { isPrimitive } from '../lib/is-primitive.func';
+import { isRegExp } from '../lib/is-regexp.func';
+import { isString } from '../lib/is-string.func';
+import { isStringIncludes } from '../lib/is-string-includes.func';
+import { isStringIncludesSome } from '../lib/is-string-includes-some.func';
+import { isStringLength } from '../lib/is-string-length.func';
+import { isStringLengthBetween } from '../lib/is-string-length-between.func';
+import { isStringObject } from '../lib/is-string-object.func';
+import { isStringType } from '../lib/is-string-type.func';
+import { isSymbol } from '../lib/is-symbol.func';
+import { isTrue } from '../lib/is-true.func';
+import { isType } from '../lib/is-type.func';
+import { isUndefined } from '../lib/is-undefined.func';
+// Type.
 import { IsNot } from '../not/interface/is-not.interface';
-import { IsNull } from '../type/is-null.type';
-import { IsNumber } from '../type/is-number.type';
-import { IsNumberObject } from '../type/is-number-object.type';
-import { IsNumberType } from '../type/is-number-type.type';
-import { IsObject } from '../type/is-object.type';
-import { IsObjectKey } from '../type/is-object-key.type';
-import { IsObjectKeyIn } from '../type/is-object-key-in.type';
-import { IsObjectKeys } from '../type/is-object-keys.type';
-import { IsPrimitive } from '../type/is-primitive.type';
-import { IsString } from '../type/is-string.type';
-import { IsStringObject } from '../type/is-string-object.type';
-import { IsStringType } from '../type/is-string-type.type';
-import { IsSymbol } from '../type/is-symbol.type';
-import { IsType } from '../type/is-type.type';
-import { IsUndefined } from '../type/is-undefined.type';
 /**
+ * Export: Interface.
  * Object with prefixed `is` functions.
  */
 export interface Is {
-  array: IsArray;
-  bigInt: IsBigInt;
-  bigint: IsBigInt;
-  boolean: IsBoolean;
-  booleanObject: IsBooleanObject;
-  booleanType: IsBooleanType;
-  class: IsClass;
-  defined: IsDefined;
-  function: IsFunction;
-  instance: IsInstance;
-  key: IsKey;
+  /**
+   * Checks if any value is of the type obtained from its object class equal to `'array'` or an `object` type and passes the test of
+   * `Array.isArray()` method.
+   */
+  array: typeof isArray;
+
+  /**
+   * Checks if any value is a `bigint` type.
+   */
+  bigint: typeof isBigInt;
+
+  /**
+   * Checks if any value is a `boolean` type, or the obtained type from its object class equal to `'boolean'`, or an `object` type and an
+   * instance of `Boolean` that is equal to `true` or `false`.
+   */
+  boolean: typeof isBoolean;
+
+  /**
+   * Checks if any value is of the type obtained from its object class equal to `'boolean'` or an `object` type, and an instance of
+   * `Boolean` and equal `true` or `false`.
+   */
+  booleanObject: typeof isBooleanObject;
+
+  /**
+   * Checks if any value is a `boolean` type equal to `true` or `false`.
+   */
+  booleanType: typeof isBooleanType;
+
+  /**
+   * Checks if any value is a `function` type or the type obtained from its object class equal to `'function'` and an instance of
+   * `Function`.
+   */
+  class: typeof isClass;
+
+  /**
+   * Checks if any value is of the type obtained from its object class equal to `'date'` or an `object` type, and an instance of
+   * `Date`.
+   */
+  date: typeof isDate; // From 4.2.0
+
+  /**
+   * Checks if any value is not an `undefined` type and is not equal to `undefined`.
+   */
+  defined: typeof isDefined;
+
+  /**
+   * Checks if any value is a `boolean` type or an instance of `Boolean` by using `isBoolean()` function, that is equal to `false`.
+   */
+  false: typeof isFalse; // From `4.2.0`
+
+  /**
+   * Checks if any value is a `function` type or the type obtained from its object class equal to `'function'` and an instance of
+   * `Function`.
+   */
+  function: typeof isFunction;
+
+  /**
+   * Checks if any value is an instance of a given `constructor`.
+   */
+  instance: typeof isInstance;
+
+  /**
+   * Checks if any value is one of the `string`, `number`, or `symbol` type.
+   */
+  key: typeof isKey;
+
+  /**
+   * Property of an object consists of `isNot` prefixed functions.
+   */
   not: IsNot;
-  null: IsNull;
-  number: IsNumber;
-  numberObject: IsNumberObject;
-  numberType: IsNumberType;
-  object: IsObject;
-  objectKey: IsObjectKey;
-  objectKeyIn: IsObjectKeyIn;
-  objectKeys: IsObjectKeys;
-  primitive: IsPrimitive;
-  string: IsString;
-  stringObject: IsStringObject;
-  stringType: IsStringType;
-  symbol: IsSymbol;
-  type: IsType;
-  undefined: IsUndefined;
+
+  /**
+   * Checks if any value is of the type obtained from its object class equal to `'null'` or an `object` type that is equal to `null`.
+   */
+  null: typeof isNull;
+
+  /**
+   * Checks if any value is a `number` type, or the type obtained from its `Object.prototype` equal to `'number'` or an `object` type
+   * and an instance of `Number`.
+   */
+  number: typeof isNumber;
+
+  /**
+   * Checks if any value is a `number` type or an instance of `Number` by using `isNumber()` between a specified range.
+   */
+  numberBetween: typeof isNumberBetween; // From `4.2.0`
+
+  /**
+   * Checks if any value is of the type obtained from its object class equal to `'number'`, or an `object` type and an instance of `Number`
+   * and **finite** by using the `Number.isFinite()` method and is **valid** by using the `Number.isNaN()` method.
+   */
+  numberObject: typeof isNumberObject;
+
+  /**
+   * Checks if any value is a `number` type and finite by using the `Number.isFinite()` method and valid by the `Number.isNaN()` method.
+   */
+  numberType: typeof isNumberType;
+
+  /**
+   * Checks if any value is an `object` type or the type obtained from its `Object.prototype` equal to `'object'`, and an instance of
+   * `Object`.
+   */
+  object: typeof isObject;
+
+  /**
+   * Checks if any value is an `object` by using the `isObject()` function with its key of the `PropertyKey` type.
+   */
+  objectKey: typeof isObjectKey;
+
+  /**
+   * Checks if any value is an `object` by using the `isObject()` function with a key of the `PropertyKey` in it(or its prototype chain) by
+   * using the `in` operator.
+   */
+  objectKeyIn: typeof isObjectKeyIn;
+
+  /**
+   * Checks if any value is an `object`(by using the `isObject()`) with its keys by using `hasOwnProperty()` method of `Object`.
+   */
+  objectKeys: typeof isObjectKeys;
+
+  /**
+   * Checks if any value is an `object` by using the `isObject()` function with keys of the `PropertyKey` in it(or its prototype chain) by
+   * using the `in` operator.
+   */
+  objectKeysIn: typeof isObjectKeysIn;
+
+  /**
+   * Checks if any value is an `object` by using the `isObject()` function with some of its keys or some groups of its keys of the
+   * `PropertyKey` type.
+   */
+  objectSomeKeys: typeof isObjectSomeKeys;
+
+  /**
+   * Checks if any value is of the generic type `Primitive` or specific type from a given `type` of the generic type `Primitives`.
+   */
+  primitive: typeof isPrimitive;
+
+  /**
+   * Checks if any value is a regular expression of the type obtained from its object class equal to `'regexp'`, or an `object` type,
+   * and an instance of `RegExp`.
+   */
+  regexp: typeof isRegExp; // From 4.2.0
+
+  /**
+   * Checks if any value is a `string` type by using the `isStringType()` function or an instance of `String` by using the
+   * `isStringObject()` function.
+   */
+  string: typeof isString;
+
+  /**
+   * Checks if any `value` is a `string` type and it's not an instance of `Object` and `String` or it's an `object` type, and an instance
+   * of `String` and `Object` that includes all of the specified words.
+   */
+  stringIncludes: typeof isStringIncludes;
+
+  /**
+   * Checks if any value is a `string` type or an instance of `String` by using `isString()` that includes some of the specified
+   * words/sentences.
+   */
+  stringIncludesSome: typeof isStringIncludesSome;
+
+  /**
+   * Checks if any value is a `string` type or an instance of `String`(by using `isString()`) of a specified length.
+   */
+  stringLength: typeof isStringLength;
+
+  /**
+   * Checks if any value is a `string` type or an instance of `String` by using `isString()` of length within the specified range.
+   */
+  stringLengthBetween: typeof isStringLengthBetween;
+
+  /**
+   * Checks if any value is of the type obtained from its `Object.prototype` equal to `'string'` or an `object` type, and an instance of
+   * `String`.
+   */
+  stringObject: typeof isStringObject;
+
+  /**
+   * Checks if any value is a `string` type.
+   */
+  stringType: typeof isStringType;
+
+  /**
+   * Checks if any `value` is a `symbol` type.
+   */
+  symbol: typeof isSymbol;
+
+  /**
+   * Checks if any value is a `boolean` type or an instance of `Boolean`(by using the `isBoolean()`) equal to `true`.
+   */
+  true: typeof isTrue; // From 4.2.0
+
+  /**
+   * Checks if any value is the type from a given `type` of the generic type `Types`.
+   */
+  type: typeof isType;
+
+  /**
+   * Checks if any value is an `undefined` type.
+   */
+  undefined: typeof isUndefined;
 }
diff --git a/src/is/lib/is-array.func.ts b/src/is/lib/is-array.func.ts
index 40c1e910..58a177ba 100644
--- a/src/is/lib/is-array.func.ts
+++ b/src/is/lib/is-array.func.ts
@@ -2,22 +2,26 @@
 import { resultCallback } from '../../lib/result-callback.func';
 import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsArray } from '../type/is-array.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `Array`, `Array` instance, and `object` type.
- * @param value Any `value` to check.
- * @param callback `ResultCallback` function to handle result before returns.
- * @returns A `boolean` indicating whether or not the `value` is an `Array`.
+ * Checks if any value is of the type obtained from its object class equal to `'array'` or an `object` type and passes the test of
+ * `Array.isArray()` method.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an `Array`.
+ * @angularpackage
  */
-export const isArray: IsArray = <Type = any>(
+export const isArray = <Type = any, Payload extends object = object>(
   value: any,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is Array<Type> =>
   callback(
-    typeOf(value) === 'array' &&
-    Array.isArray(value) === true &&
-    value instanceof Array === true &&
-    typeof value === 'object',
-    value
+    (typeOf(value) === 'array' || typeof value === 'object') &&
+      Array.isArray(value),
+    value,
+    payload
   );
diff --git a/src/is/lib/is-big-int.func.ts b/src/is/lib/is-big-int.func.ts
index 605fd4c7..85c70440 100644
--- a/src/is/lib/is-big-int.func.ts
+++ b/src/is/lib/is-big-int.func.ts
@@ -1,17 +1,19 @@
 // Function.
 import { resultCallback } from '../../lib/result-callback.func';
-import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsBigInt } from '../type/is-big-int.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is a `bigint` type.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `bigint`.
+ * Checks if any value is a `bigint` type.
+ * @param value The value of `any` type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `bigint`.
+ * @angularpackage
  */
-export const isBigInt: IsBigInt = (
+export const isBigInt = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
-): value is bigint =>
-  callback(typeOf(value) === 'bigint' && typeof value === 'bigint', value);
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is bigint => callback(typeof value === 'bigint', value, payload);
diff --git a/src/is/lib/is-boolean-object.func.ts b/src/is/lib/is-boolean-object.func.ts
index 44462cae..31bd195a 100644
--- a/src/is/lib/is-boolean-object.func.ts
+++ b/src/is/lib/is-boolean-object.func.ts
@@ -1,22 +1,28 @@
 // Function.
 import { resultCallback } from '../../lib/result-callback.func';
+import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsBooleanObject } from '../type/is-boolean-object.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `object` type and instance of `Boolean` and `Object`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `Boolean` instance.
+ * Checks if any value is of the type obtained from its object class equal to `'boolean'` or an `object` type, and an instance of `Boolean`
+ * and equal `true` or `false`.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an instance of `Boolean`.
+ * @angularpackage
  */
-export const isBooleanObject: IsBooleanObject = (
+export const isBooleanObject = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
-// tslint:disable-next-line: ban-types
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is Boolean =>
   callback(
-    typeof value === 'object' &&
-    value instanceof Boolean === true &&
-    value instanceof Object === true,
-    value
+    (typeOf(value) === 'boolean' || typeof value === 'object') &&
+    value instanceof Boolean &&
+    (value.valueOf() === true || value.valueOf() === false),
+    value,
+    payload
   );
diff --git a/src/is/lib/is-boolean-type.func.ts b/src/is/lib/is-boolean-type.func.ts
index 85f48fde..1fba7cd2 100644
--- a/src/is/lib/is-boolean-type.func.ts
+++ b/src/is/lib/is-boolean-type.func.ts
@@ -1,22 +1,24 @@
 // Function.
 import { resultCallback } from '../../lib/result-callback.func';
 // Type.
-import { IsBooleanType } from '../type/is-boolean-type.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is a `boolean` type not an instance of `Boolean` and `Object`, and equal to `true` or `false`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `boolean` type.
+ * Checks if any value is a `boolean` type equal to `true` or `false`.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `boolean` type.
+ * @angularpackage
  */
-export const isBooleanType: IsBooleanType = (
+export const isBooleanType = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is boolean =>
   callback(
-    value instanceof Boolean === false &&
-    value instanceof Object === false &&
-    typeof value === 'boolean' &&
-    (value === true || value === false),
-    value
+    typeof value === 'boolean' && (value === true || value === false),
+    value,
+    payload
   );
diff --git a/src/is/lib/is-boolean.func.ts b/src/is/lib/is-boolean.func.ts
index 56c76c2d..f1837734 100644
--- a/src/is/lib/is-boolean.func.ts
+++ b/src/is/lib/is-boolean.func.ts
@@ -1,23 +1,33 @@
 // Function.
-import { isBooleanObject } from './is-boolean-object.func';
-import { isBooleanType } from './is-boolean-type.func';
 import { resultCallback } from '../../lib/result-callback.func';
 import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsBoolean } from '../type/is-boolean.type';
+import { AnyBoolean } from '../../type/any-boolean.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is a `boolean` type not instance of `Boolean` and `Object` or `object` type instance of `Boolean` and `Object`.
- * @param value Any `value` to check.
- * @param callback `ResultCallback` function to handle result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `boolean` type or `Boolean` instance.
+ * Checks if any value is a `boolean` type, or the obtained type from its object class equal to `'boolean'`, or an `object` type and an
+ * instance of `Boolean` that is equal to `true` or `false`.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `boolean` type or an instance of `Boolean`.
+ * @angularpackage
  */
-export const isBoolean: IsBoolean = (
+export const isBoolean = <
+  Type extends AnyBoolean = boolean,
+  Payload extends object = object
+>(
   value: any,
-  callback: ResultCallback = resultCallback
-): value is boolean =>
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is Type =>
   callback(
-    typeOf(value) === 'boolean' &&
-    (isBooleanType(value) || isBooleanObject(value)),
-    value
+    (typeof value === 'boolean' ||
+    typeOf(value) === 'boolean' ||
+    (typeof value === 'object' && value instanceof Boolean)) &&
+    (value.valueOf() === true || value.valueOf() === false),
+    value,
+    payload
   );
diff --git a/src/is/lib/is-class.func.ts b/src/is/lib/is-class.func.ts
index ab11c008..b48bf6b1 100644
--- a/src/is/lib/is-class.func.ts
+++ b/src/is/lib/is-class.func.ts
@@ -2,25 +2,29 @@
 import { resultCallback } from '../../lib/result-callback.func';
 import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsClass } from '../type/is-class.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any value is a `function` type, an instance of `Function` and `Object` as a generic `Class` type of `class`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `class`.
+ * Checks if any value is a `function` type or the type obtained from its object class equal to `'function'` and an instance of
+ * `Function`. It also confirms it's a `class` by checking whether the function converted with `Function.prototype.toString()` to string
+ * contains the word `class` at the beginning.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `class`.
+ * @angularpackage
  */
-// tslint:disable-next-line: ban-types
-export const isClass: IsClass = <Class = Function>(
+export const isClass = <Class = Function, Payload extends object = object>(
   value: any,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is Class =>
   callback(
-    typeOf(value) === 'function' &&
-      typeof value === 'function' &&
-      value instanceof Function === true &&
-      value instanceof Object === true
-      ? /class/.test(Function.prototype.toString.call(value).slice(0, 5))
-      : false,
-    value
+    typeof value === 'function' ||
+    (typeOf(value) === 'function' && value instanceof Function)
+    ? /class/.test(Function.prototype.toString.call(value).slice(0, 5))
+    : false,
+    value,
+    payload
   );
diff --git a/src/is/lib/is-date.func.ts b/src/is/lib/is-date.func.ts
new file mode 100644
index 00000000..2afa88ee
--- /dev/null
+++ b/src/is/lib/is-date.func.ts
@@ -0,0 +1,28 @@
+// Function.
+import { typeOf } from '../../lib/type-of.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Checks if any value is of the type obtained from its object class equal to `'date'` or an `object` type and an instance of `Date`. It
+ * confirms it's a valid date with the `isNaN()` function.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a date.
+ * @angularpackage
+ */
+export const isDate = <Payload extends object>(
+  value: any,
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is Date =>
+  callback(
+    (typeOf(value) === 'date' || typeof value === 'object') &&
+    value instanceof Date === true &&
+    !isNaN(value),
+    value,
+    payload
+  );
diff --git a/src/is/lib/is-defined.func.ts b/src/is/lib/is-defined.func.ts
index 7175cba9..5b9f64aa 100644
--- a/src/is/lib/is-defined.func.ts
+++ b/src/is/lib/is-defined.func.ts
@@ -1,23 +1,21 @@
 // Function.
 import { resultCallback } from '../../lib/result-callback.func';
-import { typeOf } from '../../lib/type-of.func';
 // Type.
 import { Defined } from '../../type/defined.type';
-import { IsDefined } from '../type/is-defined.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if a generic `Type` `value` is not an `undefined` type and is not equal to `undefined`.
- * @param value A generic `Type` `value`, by default of type detected from the `value`, to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is defined, not `undefined`.
+ * Checks if any value is not an `undefined` type and is **not** equal to `undefined`.
+ * @param value The value of generic type variable `Type` by default of type captured from itself, to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is defined, not `undefined`.
+ * @angularpackage
  */
-export const isDefined: IsDefined = <Type>(
+export const isDefined = <Type, Payload extends object = object>(
   value: Type,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<Type, Payload> = resultCallback,
+  payload?: Payload
 ): value is Defined<Type> =>
-  callback(
-    typeOf(value) !== 'undefined' &&
-    typeof value !== 'undefined' &&
-    value !== undefined,
-    value
-  );
+  callback(typeof value !== 'undefined' && value !== undefined, value, payload);
diff --git a/src/is/lib/is-false.func.ts b/src/is/lib/is-false.func.ts
new file mode 100644
index 00000000..e94ab413
--- /dev/null
+++ b/src/is/lib/is-false.func.ts
@@ -0,0 +1,26 @@
+// Function.
+import { isBoolean } from './is-boolean.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Checks if any value is a `boolean` type or an instance of `Boolean` by using `isBoolean()` function, that is equal to `false`.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `boolean` type or an instance of `Boolean` that
+ * is equal to `false`.
+ * @angularpackage
+ */
+export const isFalse = <Payload extends object>(
+  value: any,
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is false =>
+  callback(
+    isBoolean(value) ? value.valueOf() === false : false,
+    value,
+    payload
+  );
diff --git a/src/is/lib/is-function.func.ts b/src/is/lib/is-function.func.ts
index 3eb5e1e0..59b1022c 100644
--- a/src/is/lib/is-function.func.ts
+++ b/src/is/lib/is-function.func.ts
@@ -2,26 +2,30 @@
 import { resultCallback } from '../../lib/result-callback.func';
 import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { Func } from '../../type/func.type';
-import { IsFunction } from '../type/is-function.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is a `function` type, an instance of `Function` and `Object`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `function`.
+ * Checks if any value is a `function` type or the type obtained from its object class equal to `'function'` and an instance of `Function`.
+ * It also denies it's a `class` by checking whether the function converted with `Function.prototype.ToString()` to the string does not
+ * contain the word `class` at the beginning.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a function.
+ * @angularpackage
  */
-export const isFunction: IsFunction = (
+export const isFunction = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
-): value is Func =>
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is Function =>
   callback(
-    typeOf(value) === 'function' &&
-      typeof value === 'function' &&
-      value instanceof Function === true &&
-      value instanceof Object === true
+    typeof value === 'function' ||
+      (typeOf(value) === 'function' && (value as any) instanceof Function)
       ? /class/.test(Function.prototype.toString.call(value).slice(0, 5)) ===
-      false
+          false
       : false,
-    value
+    value,
+    payload
   );
diff --git a/src/is/lib/is-instance.func.ts b/src/is/lib/is-instance.func.ts
index 674ebd2c..60be7b0a 100644
--- a/src/is/lib/is-instance.func.ts
+++ b/src/is/lib/is-instance.func.ts
@@ -1,29 +1,35 @@
 // Function.
-import { isClass } from './is-class.func';
-import { isFunction } from './is-function.func';
 import { isObject } from './is-object.func';
 import { resultCallback } from '../../lib/result-callback.func';
 // Type.
 import { Constructor } from '../../type/constructor.type';
-import { IsInstance } from '../type/is-instance.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `object` of a generic `Obj` type and an `instance` of `Constructor` type.
- * @param value Any `value` to be an instance of the `constructor`.
- * @param constructor A class or function that specifies the type of the `constructor`.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns  A `boolean` indicating whether or not the `value` is an instance of a generic `Obj`.
+ * Checks if any value is an instance of a given `constructor`.
+ * @param value The value of any type to be an instance of a given `constructor`.
+ * @param constructor A `class` or `function` that specifies the type of constructor.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with `constructor` under `ctor` name and optional properties from
+ * the provided `payload`, to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an instance of a given `constructor`.
+ * @angularpackage
  */
-export const isInstance: IsInstance = <Obj>(
+export const isInstance = <Obj, Payload extends object>(
   value: any,
   constructor: Constructor<Obj>,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<
+    any,
+    { ctor: typeof constructor } & Payload
+  > = resultCallback,
+  payload?: Payload
 ): value is Obj =>
   callback(
-    isObject<Obj>(value)
-      ? isClass<Obj>(constructor) || isFunction(constructor)
-        ? value instanceof constructor === true
-        : false
+    isObject(value) &&
+      typeof constructor === 'function' &&
+      constructor instanceof Function
+      ? value instanceof constructor
       : false,
-    value
+    value,
+    { ...payload, ctor: constructor } as any
   );
diff --git a/src/is/lib/is-key.func.ts b/src/is/lib/is-key.func.ts
index a028b561..0d8caaed 100644
--- a/src/is/lib/is-key.func.ts
+++ b/src/is/lib/is-key.func.ts
@@ -4,20 +4,24 @@ import { isStringType } from './is-string-type.func';
 import { isSymbol } from './is-symbol.func';
 import { resultCallback } from '../../lib/result-callback.func';
 // Type.
-import { IsKey } from '../type/is-key.type';
-import { Key } from '../../type/key.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is one of the `string`, `number`, or `symbol`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `Key`.
+ * Checks if any value is one of the `string`, `number`, or `symbol` type.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `PropertyKey`.
+ * @angularpackage
  */
-export const isKey: IsKey = (
+export const isKey = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
-): value is Key =>
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is PropertyKey =>
   callback(
     isStringType(value) || isNumberType(value) || isSymbol(value),
-    value
+    value,
+    payload
   );
diff --git a/src/is/lib/is-null.func.ts b/src/is/lib/is-null.func.ts
index da11fe18..bdc7832d 100644
--- a/src/is/lib/is-null.func.ts
+++ b/src/is/lib/is-null.func.ts
@@ -2,19 +2,24 @@
 import { resultCallback } from '../../lib/result-callback.func';
 import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsNull } from '../type/is-null.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `object` type and equal to `null`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is `null`.
+ * Checks if any value is of the type obtained from its object class equal to `'null'` or an `object` type that is equal to `null`.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is `null`.
+ * @angularpackage
  */
-export const isNull: IsNull = (
+export const isNull = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is null =>
   callback(
-    typeOf(value) === 'null' && typeof value === 'object' && value === null,
-    value
+    (typeOf(value) === 'null' || typeof value === 'object') && value === null,
+    value,
+    payload
   );
diff --git a/src/is/lib/is-number-between.func.ts b/src/is/lib/is-number-between.func.ts
new file mode 100644
index 00000000..fe96921c
--- /dev/null
+++ b/src/is/lib/is-number-between.func.ts
@@ -0,0 +1,44 @@
+// Function.
+import { isNumber } from './is-number.func';
+import { isNumberType } from './is-number-type.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { AnyNumber } from '../../type/any-number.type';
+import { NumberBetween } from '../../type/number-between.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Checks if any value is a `number` type or an instance of `Number`(by using `isNumber()`) between a specified range.
+ * @param value The value of any type to check.
+ * @param min The **minimum** range of generic type variable `Min` for a given `value`.
+ * @param max The **maximum** range of generic type variable `Max` for a given `value`.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the minimum and maximum `range` and optional properties from the
+ * provided `payload`, to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a finite number of a `number` type or an instance
+ * of `Number` between a specified range.
+ * @angularpackage
+ */
+export const isNumberBetween = <
+  Type extends AnyNumber = number,
+  Min extends number = number,
+  Max extends number = number,
+  Payload extends object = object
+>(
+  value: any,
+  min: Min,
+  max: Max,
+  callback: ResultCallback<
+    any,
+    { min: Min; max: Max } & Payload
+  > = resultCallback,
+  payload?: Payload
+): value is NumberBetween<Min, Max, Type> =>
+  callback(
+    isNumber(value)
+      ? (isNumberType(min) ? value.valueOf() >= min : false) &&
+          (isNumberType(max) ? value.valueOf() <= max : false)
+      : false,
+    value,
+    { ...payload, min, max } as any
+  );
diff --git a/src/is/lib/is-number-object.func.ts b/src/is/lib/is-number-object.func.ts
index 829895fb..bb03213c 100644
--- a/src/is/lib/is-number-object.func.ts
+++ b/src/is/lib/is-number-object.func.ts
@@ -1,22 +1,29 @@
 // Function.
 import { resultCallback } from '../../lib/result-callback.func';
+import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsNumberObject } from '../type/is-number-object.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `object` type and instance of `Number` and `Object`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `Number` instance.
+ * Checks if any value is of the type obtained from its object class equal to `'number'`, or an `object` type and an instance of `Number`
+ * and **finite** by using the `Number.isFinite()` method and is **valid** by using the `Number.isNaN()` method.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an instance of `Number`.
+ * @angularpackage
  */
-export const isNumberObject: IsNumberObject = (
+export const isNumberObject = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
-// tslint:disable-next-line: ban-types
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is Number =>
   callback(
-    typeof value === 'object' &&
-    value instanceof Number === true &&
-    value instanceof Object === true,
-    value
+    (typeOf(value) === 'number' || typeof value === 'object') &&
+      value instanceof Number &&
+      !Number.isNaN(value.valueOf()) &&
+      Number.isFinite(value.valueOf()),
+    value,
+    payload
   );
diff --git a/src/is/lib/is-number-type.func.ts b/src/is/lib/is-number-type.func.ts
index 9cf185a1..108489f2 100644
--- a/src/is/lib/is-number-type.func.ts
+++ b/src/is/lib/is-number-type.func.ts
@@ -1,21 +1,24 @@
 // Function.
 import { resultCallback } from '../../lib/result-callback.func';
 // Type.
-import { IsNumberType } from '../type/is-number-type.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is a `boolean` type not an instance of `Boolean` and `Object`, and equal to `true` or `false`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `number` type.
+ * Checks if any value is a `number` type and finite by using the `Number.isFinite()` method and valid by the `Number.isNaN()` method.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `number` type.
+ * @angularpackage
  */
-export const isNumberType: IsNumberType = (
+export const isNumberType = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is number =>
   callback(
-    value instanceof Number === false &&
-    value instanceof Object === false &&
-    typeof value === 'number',
-    value
+    typeof value === 'number' && Number.isFinite(value) && !Number.isNaN(value),
+    value,
+    payload
   );
diff --git a/src/is/lib/is-number.func.ts b/src/is/lib/is-number.func.ts
index a8c2524f..3e356e51 100644
--- a/src/is/lib/is-number.func.ts
+++ b/src/is/lib/is-number.func.ts
@@ -1,24 +1,36 @@
 // Function.
-import { isNumberObject } from './is-number-object.func';
-import { isNumberType } from './is-number-type.func';
 import { resultCallback } from '../../lib/result-callback.func';
 import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsNumber } from '../type/is-number.type';
+import { AnyNumber } from '../../type/any-number.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is a `number` type not an instance of `Number` and `Object` or `object` type instance of `Number` and `Object`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `number` type or `Number` object.
+ * Checks if any value is a `number` type, or the type obtained from its object class equal to `'number'` or an `object` type
+ * and an instance of `Number`. The value is also checked by the `Number.isFinite()` method to determine whether it's finite and is
+ * validated by the `Number.isNaN()` method.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a finite number of a `number` type or an instance of
+ * `Number`.
+ * @angularpackage
  */
-export const isNumber: IsNumber = (
+export const isNumber = <
+  Type extends AnyNumber = number,
+  Payload extends object = object
+>(
   value: any,
-  callback: ResultCallback = resultCallback
-): value is number =>
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is Type =>
   callback(
-    typeOf(value) === 'number' &&
-    isFinite(value) === true &&
-    (isNumberType(value) || isNumberObject(value)),
-    value
+    (typeof value === 'number' ||
+      ((typeOf(value) === 'number' || typeof value === 'object') &&
+        value instanceof Number)) &&
+      !Number.isNaN(value.valueOf()) &&
+      Number.isFinite(value.valueOf()),
+    value,
+    payload
   );
diff --git a/src/is/lib/is-object-key-in.func.ts b/src/is/lib/is-object-key-in.func.ts
index 5a673823..95df8eb6 100644
--- a/src/is/lib/is-object-key-in.func.ts
+++ b/src/is/lib/is-object-key-in.func.ts
@@ -1,31 +1,28 @@
 // Function.
-import { isArray } from './is-array.func';
-import { isKey } from './is-key.func';
 import { isObject } from './is-object.func';
 import { resultCallback } from '../../lib/result-callback.func';
 // Type.
-import { IsObjectKeyIn } from '../type/is-object-key-in.type';
-import { Key } from '../../type/key.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `Object` with the `key` of the `Key` type by using the `in` operator.
- * @param value Any `value` to check if it contains a specified `key`.
- * @param key A `Key` type or an array of `Key` type to check in the `value`.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is an `object` with the keys.
+ * Checks if any value is an `object`(by using the `isObject()`) with a key of the `PropertyKey` in it(or its prototype chain) by
+ * using the `in` operator.
+ * @param value The value of any type to check against an `object` that contains(or its prototype chain) key from a given `key`.
+ * @param key A property key to check if a given `value` contains(or its prototype chain).
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the provided `key` and optional properties from the provided `payload`,
+ * to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an `object` that contains(or its prototype chain) a
+ * given `key`.
+ * @angularpackage
  */
-export const isObjectKeyIn: IsObjectKeyIn = <Type = object>(
+export const isObjectKeyIn = <Obj = object, Payload extends object = object>(
   value: any,
-  key: Key | Key[],
-  callback: ResultCallback = resultCallback
-): value is Type =>
-  callback(
-    isObject<Type>(value)
-      ? isArray(key)
-        ? key.every((k) => (isKey(k) ? k in value : false))
-        : isKey(key)
-          ? key in value
-          : false
-      : false,
-    value
-  );
+  key: PropertyKey,
+  callback: ResultCallback<any, { key: typeof key } & Payload> = resultCallback,
+  payload?: Payload
+): value is Obj =>
+  callback(isObject(value) ? key in value : false, value, {
+    ...payload,
+    key,
+  } as any);
diff --git a/src/is/lib/is-object-key.func.ts b/src/is/lib/is-object-key.func.ts
index a27edb91..de372df4 100644
--- a/src/is/lib/is-object-key.func.ts
+++ b/src/is/lib/is-object-key.func.ts
@@ -1,33 +1,30 @@
 // Function.
-import { isArray } from './is-array.func';
-import { isKey } from './is-key.func';
 import { isObject } from './is-object.func';
 import { resultCallback } from '../../lib/result-callback.func';
 // Type.
-import { IsObjectKey } from '../type/is-object-key.type';
-import { Key } from '../../type/key.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `object` with its own specified `key` of the `Key` type.
- * @param value Any `value` to check if it contains a specified `key`.
- * @param key A `Key` type or an array of `Key` type to check the `value`.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is an `object` with its own specified keys.
+ * Checks if any value is an `object`(by using the `isObject()`) with its key of the `PropertyKey` type.
+ * @param value The value of any type to check against an `object` that contains a key from a given `key`.
+ * @param key A property key to check if a given `value` contains.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the provided `key` and optional properties from the provided
+ * `payload`, to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an `object` with its `key`.
+ * @angularpackage
  */
-export const isObjectKey: IsObjectKey = <Type = object>(
+export const isObjectKey = <
+  Obj extends object,
+  Payload extends object = object
+>(
   value: any,
-  key: Key | Key[],
-  callback: ResultCallback = resultCallback
-): value is Type =>
+  key: PropertyKey,
+  callback: ResultCallback<any, { key: typeof key } & Payload> = resultCallback,
+  payload?: Payload
+): value is Obj =>
   callback(
-    isObject<Type>(value)
-      ? isArray(key)
-        ? key.every((k) =>
-          isKey(k) ? {}.hasOwnProperty.call(value, k) === true : false
-        )
-        : isKey(key)
-          ? {}.hasOwnProperty.call(value, key)
-          : false
-      : false,
-    value
+    isObject(value) ? {}.hasOwnProperty.call(value, key) : false,
+    value,
+    { ...payload, key } as any
   );
diff --git a/src/is/lib/is-object-keys-in.func.ts b/src/is/lib/is-object-keys-in.func.ts
new file mode 100644
index 00000000..c6090c35
--- /dev/null
+++ b/src/is/lib/is-object-keys-in.func.ts
@@ -0,0 +1,33 @@
+// Function.
+import { isArray } from './is-array.func';
+import { isObject } from './is-object.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Checks if any value is an `object`(by using the `isObject()`) with keys of the `PropertyKey` in it(or its prototype chain) by using the
+ * `in` operator.
+ * @param value The value of any type to check against the `object` that contains(or its prototype chain) keys from the given `keys`.
+ * @param key An array of property keys to check if the given `value` contains(or its prototype chain).
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the provided `keys` and optional properties from the provided
+ * `payload`, to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an `object` that contains(or its prototype chain)
+ * given `keys`.
+ * @angularpackage
+ */
+export const isObjectKeysIn = <Obj = object, Payload extends object = object>(
+  value: any,
+  keys: PropertyKey[],
+  callback: ResultCallback<
+    any,
+    { keys: typeof keys } & Payload
+  > = resultCallback,
+  payload?: Payload
+): value is Obj =>
+  callback(
+    isObject(value) && isArray(keys) ? keys.every((k) => k in value) : false,
+    value,
+    { ...payload, keys } as any
+  );
diff --git a/src/is/lib/is-object-keys.func.ts b/src/is/lib/is-object-keys.func.ts
index 8ae23ab4..c35a076b 100644
--- a/src/is/lib/is-object-keys.func.ts
+++ b/src/is/lib/is-object-keys.func.ts
@@ -1,28 +1,33 @@
 // Function.
 import { isArray } from './is-array.func';
-import { isKey } from './is-key.func';
-// Type.
-import { IsObjectKeys } from '../type/is-object-keys.type';
-import { Key } from '../../type/key.type';
 import { isObject } from './is-object.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `object` of a generic `Type` with some of its own specified `keys`.
- * @param value Any `value` to check if it contains some of the specified `keys`.
- * @param keys A rest parameter key of `Type` or an array of keys of `Type` to check the `value`.
- * @returns A `boolean` indicating whether or not the `value` is an `object` with some of its own specified keys.
+ * Checks if any value is an `object`(by using the `isObject()`) with its keys by using `hasOwnProperty()` method of `Object`.
+ * @param value The value of any type to check against an `object` that contains its keys from given `keys`.
+ * @param keys An `Array` of property keys to check if a given `value` contains.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the provided `keys` and optional properties from the provided
+ * `payload`, to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an `object` with its `keys`.
+ * @angularpackage
  */
-export const isObjectKeys: IsObjectKeys = <Type = object>(
+export const isObjectKeys = <Obj = object, Payload extends object = object>(
   value: any,
-  ...keys: (Key | Array<Key>)[]
-): value is Type =>
-  isObject<Type>(value)
-    ? keys.some((key) =>
-      isArray(key)
-        ? key.every((k) =>
-          isKey(k) ? {}.hasOwnProperty.call(value, k) === true : false
-        )
-        : isKey(key)
-          ? {}.hasOwnProperty.call(value, key) === true
-          : false
-    )
-    : false;
+  keys: PropertyKey[],
+  callback: ResultCallback<
+    any,
+    { keys: typeof keys } & Payload
+  > = resultCallback,
+  payload?: Payload
+): value is Obj =>
+  callback(
+    isObject(value) && isArray(keys)
+      ? keys.every((key) => ({}.hasOwnProperty.call(value, key)))
+      : false,
+    value,
+    { ...payload, keys } as any
+  );
diff --git a/src/is/lib/is-object-some-keys.func.ts b/src/is/lib/is-object-some-keys.func.ts
new file mode 100644
index 00000000..c81bd734
--- /dev/null
+++ b/src/is/lib/is-object-some-keys.func.ts
@@ -0,0 +1,45 @@
+// Function.
+import { isArray } from './is-array.func';
+import { isObject } from './is-object.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Checks if any value is an `object`(by using the `isObject()`) with some of its keys or some groups of its keys of the `PropertyKey` type.
+ * @param value The value of any type to check against an `object` that contains some of its keys or some groups of its keys from
+ * a given `keys`.
+ * @param keys An `Array` of property names or a two-dimensional `array` of property names to check if the given `value` contains some of
+ * them or some groups of them.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the provided `keys` and optional properties from the provided
+ * `payload`, to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an `object` with some of its keys or some groups of
+ * its keys from a given `keys`.
+ * @angularpackage
+ */
+export const isObjectSomeKeys = <
+  Obj extends object,
+  Payload extends object = object
+>(
+  value: any,
+  keys: (PropertyKey | PropertyKey[])[],
+  callback: ResultCallback<
+    any,
+    { keys: typeof keys } & Payload
+  > = resultCallback,
+  payload?: Payload
+): value is Obj =>
+  callback(
+    isObject(value) && isArray(keys)
+      ? keys.some((someKey) =>
+          isArray(someKey)
+            ? someKey.every((everyKey) =>
+                ({}.hasOwnProperty.call(value, everyKey))
+              )
+            : {}.hasOwnProperty.call(value, someKey) === true
+        )
+      : false,
+    value,
+    { ...payload, keys } as any
+  );
diff --git a/src/is/lib/is-object.func.ts b/src/is/lib/is-object.func.ts
index d4fd358a..7fd24258 100644
--- a/src/is/lib/is-object.func.ts
+++ b/src/is/lib/is-object.func.ts
@@ -2,21 +2,26 @@
 import { resultCallback } from '../../lib/result-callback.func';
 import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsObject } from '../type/is-object.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `object` of a generic `Obj` type and `Object` instance.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is an `object`.
+ * Checks if any value is an `object` type or the type obtained from its object class equal to `'object'`, and an instance of
+ * `Object`.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an `object`.
+ * @angularpackage
  */
-export const isObject: IsObject = <Obj = object>(
+export const isObject = <Obj = object, Payload extends object = object>(
   value: any,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is Obj =>
   callback(
-    typeOf(value) === 'object' &&
-    typeof value === 'object' &&
-    value instanceof Object === true,
-    value
+    (typeof value === 'object' || typeOf(value) === 'object') &&
+      value instanceof Object,
+    value,
+    payload
   );
diff --git a/src/is/lib/is-param.decorator.ts b/src/is/lib/is-param.decorator.ts
index 620b0fa2..63c89d43 100644
--- a/src/is/lib/is-param.decorator.ts
+++ b/src/is/lib/is-param.decorator.ts
@@ -1,8 +1,7 @@
-import { Func } from '../../type/func.type';
 import { is } from './is.object';
 
 export function isParam(...param: Array<string>): MethodDecorator {
-  return (target: Func | object, key: string | symbol, descriptor: any): any => {
+  return (target: Function | object, key: string | symbol, descriptor: any): any => {
     const originalMethod = descriptor.value;
 
     descriptor.value =  function(): void {
diff --git a/src/is/lib/is-primitive.func.ts b/src/is/lib/is-primitive.func.ts
index 10124c88..760df78e 100644
--- a/src/is/lib/is-primitive.func.ts
+++ b/src/is/lib/is-primitive.func.ts
@@ -8,32 +8,42 @@ import { isSymbol } from './is-symbol.func';
 import { isUndefined } from './is-undefined.func';
 import { resultCallback } from '../../lib/result-callback.func';
 // Type.
-import { IsPrimitive } from '../type/is-primitive.type';
 import { Primitive } from '../../type/primitive.type';
 import { Primitives } from '../../type/primitives.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is the `Primitive` type from a `type` of the `Primitives` type.
- * @param value Any `value` to check if it's a `Primitive` from the `type`.
- * @param type A `string` type from the `Primitives` to check the `value`.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `type` from the `Primitives`.
+ * Checks if any value is of the generic type `Primitive` or specific type from a given `type` of the generic type `Primitives`.
+ * @param value The value` of any type to check.
+ * @param type An optional value of `Primitives` type indicates against which type the provided `value` is checked.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the provided `type` of `Primitives` and additional properties from the
+ * provided `payload`, to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a type of the `Primitives`.
+ * @angularpackage
  */
-export const isPrimitive: IsPrimitive = <T extends Primitive>(
+export const isPrimitive = <
+  Type extends Primitive,
+  Payload extends object = object
+>(
   value: any,
-  type: Primitives,
-  callback: ResultCallback = resultCallback
-): value is T => {
-  if (isStringType(type)) {
-    switch (type) {
-      case 'bigint': return isBigInt(value, callback);
-      case 'boolean': return isBooleanType(value, callback);
-      case 'number': return isNumberType(value, callback);
-      case 'null': return isNull(value, callback);
-      case 'string': return isStringType(value, callback);
-      case 'symbol': return isSymbol(value, callback);
-      case 'undefined': return isUndefined(value, callback);
-    }
-  }
-  return false;
-};
+  type?: Primitives,
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is Type =>
+  isStringType(type)
+    ? {
+        bigint: isBigInt,
+        boolean: isBooleanType,
+        number: isNumberType,
+        null: isNull,
+        string: isStringType,
+        symbol: isSymbol,
+        undefined: isUndefined,
+      }[type](value, callback, payload)
+    : callback(
+        isNull(value) ||
+          (typeof value !== 'object' && typeof value !== 'function'),
+        value,
+        payload
+      );
diff --git a/src/is/lib/is-regexp.func.ts b/src/is/lib/is-regexp.func.ts
new file mode 100644
index 00000000..0fea66fd
--- /dev/null
+++ b/src/is/lib/is-regexp.func.ts
@@ -0,0 +1,27 @@
+// Function.
+import { resultCallback } from '../../lib/result-callback.func';
+import { typeOf } from '../../lib/type-of.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Checks if any value is a regular expression of the type obtained from its object class equal to `'regexp'`, or an `object` type,
+ * and an instance of `RegExp`.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a regular expression.
+ * @angularpackage
+ */
+export const isRegExp = <Payload extends object>(
+  value: any,
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is RegExp =>
+  callback(
+    (typeOf(value) === 'regexp' || typeof value === 'object') &&
+      value instanceof RegExp,
+    value,
+    payload
+  );
diff --git a/src/is/lib/is-string-gen.func.ts b/src/is/lib/is-string-gen.func.ts
deleted file mode 100644
index 576493a8..00000000
--- a/src/is/lib/is-string-gen.func.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-
-function* isStringGenerator(value: any): Generator {
-  yield typeOf(value) === 'string';
-  yield isStringType(value);
-  yield isStringObject(value);
-}
-
-function isStringChecks(value: any, callback: any) {
-  const gen: Generator = isStringGenerator(value);
-  for (const val of gen) {
-    callback(gen);
-  }
-}
diff --git a/src/is/lib/is-string-includes-some.func.ts b/src/is/lib/is-string-includes-some.func.ts
new file mode 100644
index 00000000..bb91c5dd
--- /dev/null
+++ b/src/is/lib/is-string-includes-some.func.ts
@@ -0,0 +1,41 @@
+// Function.
+import { isArray } from './is-array.func';
+import { isString } from './is-string.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { AnyString } from '../../type/any-string.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Checks if any value is a `string` type or an instance of `String`(by using `isString()`) that includes some of the specified
+ * words/sentences.
+ * @param value The value of any type to check against the `string` that `includes` some of the words/sentences.
+ * @param includes An `Array` of `string` as words/sentences to be case-sensitive searched for within a given `value`.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the `includes` and optional properties from the provided `payload`,
+ * to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `string` type or an instance of `String` that
+ * includes some of the specified words/sentences.
+ * @angularpackage
+ */
+export const isStringIncludesSome = <
+  Type extends AnyString = string,
+  Payload extends object = object
+>(
+  value: any,
+  includes: string[],
+  callback: ResultCallback<
+    any,
+    { includes: typeof includes } & Payload
+  > = resultCallback,
+  payload?: Payload
+): value is Type =>
+  callback(
+    isString(value)
+      ? isArray(includes)
+        ? includes.some((include) => value.valueOf().includes(include))
+        : false
+      : false,
+    value,
+    { ...payload, includes } as any
+  );
diff --git a/src/is/lib/is-string-includes.func.ts b/src/is/lib/is-string-includes.func.ts
new file mode 100644
index 00000000..5a1ced60
--- /dev/null
+++ b/src/is/lib/is-string-includes.func.ts
@@ -0,0 +1,41 @@
+// Function.
+import { isArray } from './is-array.func';
+import { isString } from './is-string.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { AnyString } from '../../type/any-string.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Checks if any value is a `string` type or an instance of `String`(by using `isString()`) that includes all of the specified
+ * words/sentences.
+ * @param value The value of any type to check against the `string` that contains words/sentences from a given `includes`.
+ * @param includes An `Array` of `string` as words/sentences to be case-sensitive searched for within the given `value`.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the `includes` and optional properties from the provided `payload`,
+ * to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `string` type or an instance of `String` that
+ * includes all of the specified words/sentences.
+ * @angularpackage
+ */
+export const isStringIncludes = <
+  Type extends AnyString = string,
+  Payload extends object = object
+>(
+  value: any,
+  includes: string[],
+  callback: ResultCallback<
+    any,
+    { includes: typeof includes } & Payload
+  > = resultCallback,
+  payload?: Payload
+): value is Type =>
+  callback(
+    isString(value)
+      ? isArray(includes)
+        ? includes.every((include) => value.valueOf().includes(include))
+        : false
+      : false,
+    value,
+    { ...payload, includes } as any
+  );
diff --git a/src/is/lib/is-string-length-between.func.ts b/src/is/lib/is-string-length-between.func.ts
new file mode 100644
index 00000000..0d2fb31d
--- /dev/null
+++ b/src/is/lib/is-string-length-between.func.ts
@@ -0,0 +1,48 @@
+// Function.
+import { isNumberType } from './is-number-type.func';
+import { isString } from './is-string.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { AnyString } from '../../type/any-string.type';
+import { ResultCallback } from '../../type/result-callback.type';
+import { StringOfLength } from '../../type/string-of-length.type';
+/**
+ * Checks if any value is a `string` type or an instance of `String` by using `isString()` of length within the specified range.
+ * @param value The value of any type to check.
+ * @param min The **minimum** length of generic type variable `Min` of a given `value`.
+ * @param max The **maximum** length of generic type variable `Max` of a given `value`.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the minimum and maximum `length` and optional properties from the
+ * provided `payload`, to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `string` type or an instance of `String` of length
+ * within the specified range.
+ * @angularpackage
+ */
+export const isStringLengthBetween = <
+  Type extends AnyString = string,
+  Min extends number = number,
+  Max extends number = number,
+  Payload extends object = object
+>(
+  value: any,
+  min: Min,
+  max: Max,
+  callback: ResultCallback<
+    any,
+    { min: Min; max: Max } & Payload
+  > = resultCallback,
+  payload?: Payload
+): value is StringOfLength<Min, Max, Type> =>
+  callback(
+    isString(value)
+      ? (isNumberType(min) && min >= 0
+          ? value.valueOf().length >= min
+          : false) &&
+          (isNumberType(max) && max >= 0
+            ? value.valueOf().length <= max
+            : false)
+      : false,
+    value,
+    { ...payload, min, max } as any
+  );
diff --git a/src/is/lib/is-string-length.func.ts b/src/is/lib/is-string-length.func.ts
new file mode 100644
index 00000000..f4f96160
--- /dev/null
+++ b/src/is/lib/is-string-length.func.ts
@@ -0,0 +1,37 @@
+// Function.
+import { isNumberType } from './is-number-type.func';
+import { isString } from './is-string.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { AnyString } from '../../type/any-string.type';
+import { ResultCallback } from '../../type/result-callback.type';
+import { StringOfLength } from '../../type/string-of-length.type';
+/**
+ * Checks if any value is a `string` type or an instance of `String`(by using `isString()`) of a specified length.
+ * @param value The value of any type to check.
+ * @param length The length of generic type variable `Length` of a given `value`.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload`, with the minimum and maximum `length` and optional properties from the
+ * provided `payload`, to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `string` type or an instance of `String` of the
+ * specified length.
+ * @angularpackage
+ */
+export const isStringLength = <
+  Type extends AnyString = string,
+  Length extends number = number,
+  Payload extends object = object
+>(
+  value: any,
+  length: Length,
+  callback: ResultCallback<any, { length: Length } & Payload> = resultCallback,
+  payload?: Payload
+): value is StringOfLength<Length, Length, Type> =>
+  callback(
+    isString(value) && isNumberType(length) && length > 0
+      ? value.valueOf().length === length
+      : false,
+    value,
+    { ...payload, length } as any
+  );
diff --git a/src/is/lib/is-string-object.func.ts b/src/is/lib/is-string-object.func.ts
index efb39053..7c4bff16 100644
--- a/src/is/lib/is-string-object.func.ts
+++ b/src/is/lib/is-string-object.func.ts
@@ -1,22 +1,26 @@
 // Function.
 import { resultCallback } from '../../lib/result-callback.func';
+import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsStringObject } from '../type/is-string-object.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `object` type instance of `String` and `Object`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `String` instance.
+ * Checks if any value is of the type obtained from its object class equal to `'string'` or an `object` type, and an instance of `String`.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is an instance of `String`.
+ * @angularpackage
  */
-export const isStringObject: IsStringObject = (
+export const isStringObject = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
-// tslint:disable-next-line: ban-types
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is String =>
   callback(
-    value instanceof Object === true &&
-    value instanceof String === true &&
-    typeof value === 'object',
-    value
+    (typeOf(value) === 'string' || typeof value === 'object') &&
+    value instanceof String,
+    value,
+    payload
   );
diff --git a/src/is/lib/is-string-type.func.ts b/src/is/lib/is-string-type.func.ts
index 94fbddb0..c62fe353 100644
--- a/src/is/lib/is-string-type.func.ts
+++ b/src/is/lib/is-string-type.func.ts
@@ -1,21 +1,20 @@
 // Function.
 import { resultCallback } from '../../lib/result-callback.func';
 // Type.
-import { IsStringType } from '../type/is-string-type.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is a `string` type not instance of `String` and `Object`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the value is a `string` type.
+ * Checks if any value is a `string` type.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `string` type.
+ * @angularpackage
  */
-export const isStringType: IsStringType = (
+export const isStringType = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is string =>
-  callback(
-    value instanceof Object === false &&
-    value instanceof String === false &&
-    typeof value === 'string',
-    value
-  );
+  callback(typeof value === 'string', value, payload);
diff --git a/src/is/lib/is-string.func.ts b/src/is/lib/is-string.func.ts
index 7e462c99..aab4bd3b 100644
--- a/src/is/lib/is-string.func.ts
+++ b/src/is/lib/is-string.func.ts
@@ -1,23 +1,27 @@
 // Function.
+import { resultCallback } from '../../lib/result-callback.func';
 import { isStringObject } from './is-string-object.func';
 import { isStringType } from './is-string-type.func';
-import { resultCallback } from '../../lib/result-callback.func';
-import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsString } from '../type/is-string.type';
+import { AnyString } from '../../type/any-string.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is a `string` type, not instance of `Object` and `String` or `object` type and instance of `String` and `Object`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `string` type or `String` object.
+ * Checks if any value is a `string` type by using the `isStringType()` function or an instance of `String` by using the `isStringObject()`
+ * function.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `string` type or an instance of `String`.
+ * @angularpackage
  */
-export const isString: IsString = (
+export const isString = <
+  Type extends AnyString = string,
+  Payload extends object = object
+>(
   value: any,
-  callback: ResultCallback = resultCallback
-): value is string =>
-  callback(
-    typeOf(value) === 'string' &&
-    (isStringType(value) || isStringObject(value)),
-    value
-  );
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is Type =>
+  callback(isStringType(value) || isStringObject(value), value, payload);
diff --git a/src/is/lib/is-symbol.func.ts b/src/is/lib/is-symbol.func.ts
index f9c4c959..760d514f 100644
--- a/src/is/lib/is-symbol.func.ts
+++ b/src/is/lib/is-symbol.func.ts
@@ -1,17 +1,22 @@
 // Function.
 import { resultCallback } from '../../lib/result-callback.func';
-import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsSymbol } from '../type/is-symbol.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is a `symbol` type.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is a `symbol`.
+ * Checks if any value is a `symbol` type.
+ * @var Payload The `Payload` generic type variable constrained by `object` indicates the type of optional parameter `payload` of the
+ * supplied `callback` function and `payload` optional parameter of the `isSymbol()` function from which it captures its value.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `symbol`.
+ * @angularpackage
  */
-export const isSymbol: IsSymbol = (
+export const isSymbol = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
 ): value is symbol =>
-  callback(typeOf(value) === 'symbol' && typeof value === 'symbol', value);
+  callback(typeof value === 'symbol', value, payload);
diff --git a/src/is/lib/is-true.func.ts b/src/is/lib/is-true.func.ts
new file mode 100644
index 00000000..b28161f6
--- /dev/null
+++ b/src/is/lib/is-true.func.ts
@@ -0,0 +1,22 @@
+// Function.
+import { isBoolean } from './is-boolean.func';
+import { resultCallback } from '../../lib/result-callback.func';
+// Type.
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Checks if any value is a `boolean` type or an instance of `Boolean`(by using the `isBoolean()`) equal to `true`.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a `boolean` type or an instance of `Boolean` that is
+ * equal to `true`.
+ * @angularpackage
+ */
+export const isTrue = <Payload extends object>(
+  value: any,
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is true =>
+  callback(isBoolean(value) ? value.valueOf() === true : false, value, payload);
diff --git a/src/is/lib/is-type.func.ts b/src/is/lib/is-type.func.ts
index a1e31581..ee6d01b7 100644
--- a/src/is/lib/is-type.func.ts
+++ b/src/is/lib/is-type.func.ts
@@ -1,45 +1,50 @@
 // Function.
+import { isBigInt } from './is-big-int.func';
+import { isBooleanType } from './is-boolean-type.func';
 import { isFunction } from './is-function.func';
 import { isInstance } from './is-instance.func';
 import { isNotNull } from '../not/lib/is-not-null.func';
+import { isNull } from './is-null.func';
+import { isNumberType } from './is-number-type.func';
 import { isObject } from './is-object.func';
-import { isPrimitive } from './is-primitive.func';
 import { isStringType } from './is-string-type.func';
+import { isSymbol } from './is-symbol.func';
+import { isUndefined } from './is-undefined.func';
 import { resultCallback } from '../../lib/result-callback.func';
 // Type.
-import { IsType } from '../type/is-type.type';
+import { Primitives } from '../../type/primitives.type';
 import { ResultCallback } from '../../type/result-callback.type';
 import { Type } from '../../type/type.type';
 import { Types } from '../../type/types.type';
 /**
- * Checks if any `value` is the `Type` from a `type` of the `Types` type.
- * @param value Any `value` to check if its type is from the `type`.
- * @param type A `string` or generic `Constructor` type from the `Types` to check the `value`.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is the `Type` from a `type` of the `Types`.
+ * Checks if any value is the type from a given `type` of the generic type `Types`.
+ * @param value The value of any type to check against the type of given `type`.
+ * @param type A value of the generic type `Types` indicates against which type the provided `value` is checked.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with the provided `type` and optional properties from the provided
+ * `payload`, to handle them before the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is a type from a given `type`.
+ * @angularpackage
  */
-export const isType: IsType = <T extends Type>(
+export const isType = <T extends Type, Payload extends object = object>(
   value: any,
   type: Types<T>,
-  callback: ResultCallback = resultCallback
-): value is T => {
-  if (isStringType(type)) {
-    switch (type) {
-      // Primitives.
-      case 'bigint':
-      case 'boolean':
-      case 'number':
-      case 'null':
-      case 'string':
-      case 'symbol':
-      case 'undefined': return isPrimitive(value, type, callback);
-      // Function.
-      case 'function': return isFunction(value, callback);
-      // Object.
-      case 'object': return isObject<T>(value);
-    }
-  } else if (isNotNull(type)) {
-    return isInstance<T>(value, type, callback);
-  }
-  return false;
-};
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is T =>
+  isStringType(type)
+    ? {
+        bigint: isBigInt,
+        boolean: isBooleanType,
+        function: isFunction,
+        number: isNumberType,
+        object: isObject,
+        null: isNull,
+        string: isStringType,
+        symbol: isSymbol,
+        undefined: isUndefined,
+      }[type as Primitives](value, callback, payload)
+    : isNotNull(type)
+    ? isInstance(value, type, callback, payload)
+    : false;
diff --git a/src/is/lib/is-undefined.func.ts b/src/is/lib/is-undefined.func.ts
index bf6b624e..57070ac4 100644
--- a/src/is/lib/is-undefined.func.ts
+++ b/src/is/lib/is-undefined.func.ts
@@ -1,22 +1,19 @@
 // Function.
 import { resultCallback } from '../../lib/result-callback.func';
-import { typeOf } from '../../lib/type-of.func';
 // Type.
-import { IsUndefined } from '../type/is-undefined.type';
 import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Checks if any `value` is an `undefined` type and equal to `undefined`.
- * @param value Any `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is `undefined`.
+ * Checks if any value is an `undefined` type.
+ * @param value The value of any type to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is `undefined`.
+ * @angularpackage
  */
-export const isUndefined: IsUndefined = (
+export const isUndefined = <Payload extends object>(
   value: any,
-  callback: ResultCallback = resultCallback
-): value is undefined =>
-  callback(
-    typeOf(value) === 'undefined' &&
-    typeof value === 'undefined' &&
-    value === undefined,
-    value
-  );
+  callback: ResultCallback<any, Payload> = resultCallback,
+  payload?: Payload
+): value is undefined => callback(typeof value === 'undefined', value, payload);
diff --git a/src/is/lib/is.object.ts b/src/is/lib/is.object.ts
index 3ff25aa0..9f23c52c 100644
--- a/src/is/lib/is.object.ts
+++ b/src/is/lib/is.object.ts
@@ -5,56 +5,79 @@ import { isBoolean } from './is-boolean.func';
 import { isBooleanObject } from './is-boolean-object.func';
 import { isBooleanType } from './is-boolean-type.func';
 import { isClass } from './is-class.func';
+import { isDate } from './is-date.func';
 import { isDefined } from './is-defined.func';
+import { isFalse } from './is-false.func';
 import { isFunction } from './is-function.func';
 import { isInstance } from './is-instance.func';
 import { isKey } from './is-key.func';
 import { isNull } from './is-null.func';
 import { isNumber } from './is-number.func';
+import { isNumberBetween } from './is-number-between.func';
 import { isNumberObject } from './is-number-object.func';
 import { isNumberType } from './is-number-type.func';
 import { isObject } from './is-object.func';
 import { isObjectKey } from './is-object-key.func';
 import { isObjectKeyIn } from './is-object-key-in.func';
 import { isObjectKeys } from './is-object-keys.func';
+import { isObjectKeysIn } from './is-object-keys-in.func';
+import { isObjectSomeKeys } from './is-object-some-keys.func';
 import { isPrimitive } from './is-primitive.func';
+import { isRegExp } from './is-regexp.func';
 import { isString } from './is-string.func';
+import { isStringIncludes } from './is-string-includes.func';
+import { isStringIncludesSome } from './is-string-includes-some.func';
+import { isStringLength } from './is-string-length.func';
+import { isStringLengthBetween } from './is-string-length-between.func';
 import { isStringObject } from './is-string-object.func';
 import { isStringType } from './is-string-type.func';
 import { isSymbol } from './is-symbol.func';
+import { isTrue } from './is-true.func';
 import { isType } from './is-type.func';
 import { isUndefined } from './is-undefined.func';
 // Object.
 import { isNot } from '../not/lib/is-not.object';
 // Interface.
 import { Is } from '../interface/is.interface';
-// `is`.
-export const is: Is = {
+/**
+ * The object contains prefixed with is functions and prefixed with isNot functions in property `not`.
+ */
+export const is: Is = Object.freeze({
   array: isArray,
-  bigInt: isBigInt, // deprecated
   bigint: isBigInt,
   boolean: isBoolean,
   booleanObject: isBooleanObject,
   booleanType: isBooleanType,
   class: isClass,
+  date: isDate, // From the `4.2.0` version.
   defined: isDefined,
+  false: isFalse, // From the `4.2.0` version.
   function: isFunction,
   instance: isInstance,
   key: isKey,
   not: isNot,
   null: isNull,
   number: isNumber,
+  numberBetween: isNumberBetween, // From the `4.2.0` version.
   numberObject: isNumberObject,
   numberType: isNumberType,
   object: isObject,
   objectKey: isObjectKey,
   objectKeyIn: isObjectKeyIn,
   objectKeys: isObjectKeys,
+  objectKeysIn: isObjectKeysIn, // From the `5.0.0` version.
+  objectSomeKeys: isObjectSomeKeys, // From the `5.0.0` version.
   primitive: isPrimitive,
+  regexp: isRegExp, // From the `4.2.0` version.
   string: isString,
+  stringIncludes: isStringIncludes, // From the `5.0.0` version.
+  stringIncludesSome: isStringIncludesSome, // From the `5.0.0` version.
+  stringLength: isStringLength, // From the `4.2.0` version.
+  stringLengthBetween: isStringLengthBetween, // From the 5.0.0 version.
   stringObject: isStringObject,
   stringType: isStringType,
   symbol: isSymbol,
+  true: isTrue, // From the `4.2.0` version.
   type: isType,
   undefined: isUndefined
-};
+});
diff --git a/src/is/not/interface/is-not.interface.ts b/src/is/not/interface/is-not.interface.ts
index 1355619c..1c1afe05 100644
--- a/src/is/not/interface/is-not.interface.ts
+++ b/src/is/not/interface/is-not.interface.ts
@@ -1,23 +1,26 @@
-import { IsNotBoolean } from '../type/is-not-boolean.type';
-import { IsNotNumber } from '../type/is-not-number.type';
-import { IsNotUndefined } from '../type/is-not-undefined.type';
-import { IsNotNull } from '../type/is-not-null.type';
-import { IsNotString } from '../type/is-not-string.type';
-import { IsNotFunction } from '../type/is-not-function.type';
-import { IsNotDefined } from '../type/is-not-defined.type';
-
+// Function.
+import { isNotBoolean } from '../lib/is-not-boolean.func';
+import { isNotDefined } from '../lib/is-not-defined.func';
+import { isNotFunction } from '../lib/is-not-function.func';
+import { isNotNull } from '../lib/is-not-null.func';
+import { isNotNumber } from '../lib/is-not-number.func';
+import { isNotString } from '../lib/is-not-string.func';
+import { isNotUndefined } from '../lib/is-not-undefined.func';
+/**
+ * A shape of an object with all prefixed with `isNot` functions.
+ */
 export interface IsNot {
   // array: IsArray;
   // bigInt: IsBigInt;
-  boolean: IsNotBoolean;
-  defined: IsNotDefined;
-  function: IsNotFunction;
-  null: IsNotNull;
-  number: IsNotNumber;
+  boolean: typeof isNotBoolean;
+  defined: typeof isNotDefined;
+  function: typeof isNotFunction;
+  null: typeof isNotNull;
+  number: typeof isNotNumber;
   // object: IsObject;
   // primitive: IsPrimitive;
-  string: IsNotString;
+  string: typeof isNotString;
   // symbol: IsSymbol;
   // type: IsType;
-  undefined: IsNotUndefined;
+  undefined: typeof isNotUndefined;
 }
diff --git a/src/is/not/lib/is-not-boolean.func.ts b/src/is/not/lib/is-not-boolean.func.ts
index 3a651785..30cbe902 100644
--- a/src/is/not/lib/is-not-boolean.func.ts
+++ b/src/is/not/lib/is-not-boolean.func.ts
@@ -3,22 +3,28 @@ import { resultCallback } from '../../../lib/result-callback.func';
 import { typeOf } from '../../../lib/type-of.func';
 // Type.
 import { AnyBoolean } from '../../../type/any-boolean.type';
-import { IsNotBoolean } from '../type/is-not-boolean.type';
 import { Never } from '../../../type/never.type';
 import { ResultCallback } from '../../../type/result-callback.type';
 /**
- * Checks if a generic `Type` `value` is not a `boolean` type, and not instance of `Boolean`.
- * @param value A generic `Type` `value`, by default of type detected from the `value`, to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is not `boolean` or `Boolean` instance.
+ * Checks if the `value` is not the type obtained from its object class equal to `'boolean'`, not a `boolean` type and not an instance of
+ * `Boolean`.
+ * @param value The `value` of generic type variable `Type`, by default of the type captured from itself to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of the generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is not `boolean` type and not an instance of `Boolean`.
+ * @angularpackage
  */
-export const isNotBoolean: IsNotBoolean = <Type>(
+export const isNotBoolean = <Type, Payload extends object = object>(
   value: Type,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<Type, Payload> = resultCallback,
+  payload?: Payload
 ): value is Never<AnyBoolean, Type> =>
   callback(
     typeOf(value) !== 'boolean' &&
-    typeof value !== 'boolean' &&
-    value instanceof Boolean === false,
-    value
+      typeof value !== 'boolean' &&
+      value instanceof Boolean === false,
+    value,
+    payload
   );
diff --git a/src/is/not/lib/is-not-defined.func.ts b/src/is/not/lib/is-not-defined.func.ts
index 8215d667..591a8cbd 100644
--- a/src/is/not/lib/is-not-defined.func.ts
+++ b/src/is/not/lib/is-not-defined.func.ts
@@ -2,22 +2,28 @@
 import { resultCallback } from '../../../lib/result-callback.func';
 import { typeOf } from '../../../lib/type-of.func';
 // Type.
-import { IsNotDefined } from '../type/is-not-defined.type';
 import { ResultCallback } from '../../../type/result-callback.type';
 import { Undefined } from '../../../type/undefined.type';
 /**
- * Checks if a generic `Type` `value` is an `undefined` type and is equal to `undefined`.
- * @param value A generic `Type` `value`, by default of type detected from the `value`, to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is not defined.
+ * Checks if the `value` is **not** the type obtained from its object class equal to `'undefined'`, **not** an `undefined` type and is
+ * **not** equal to `undefined`.
+ * @param value The `value` of a generic type variable `Type`, by default of the type captured from itself to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of the generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is not defined.
+ * @angularpackage
  */
-export const isNotDefined: IsNotDefined = <Type>(
+export const isNotDefined = <Type, Payload extends object = object>(
   value: Type,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<Type, Payload> = resultCallback,
+  payload?: Payload
 ): value is Undefined<Type> =>
   callback(
     typeOf(value) === 'undefined' &&
-    typeof value === 'undefined' &&
-    value === undefined,
-    value
+      typeof value === 'undefined' &&
+      value === undefined,
+    value,
+    payload
   );
diff --git a/src/is/not/lib/is-not-function.func.ts b/src/is/not/lib/is-not-function.func.ts
index 3db02978..abac895d 100644
--- a/src/is/not/lib/is-not-function.func.ts
+++ b/src/is/not/lib/is-not-function.func.ts
@@ -2,23 +2,28 @@
 import { resultCallback } from '../../../lib/result-callback.func';
 import { typeOf } from '../../../lib/type-of.func';
 // Type.
-import { Func } from '../../../type/func.type';
-import { IsNotFunction } from '../type/is-not-function.type';
 import { Never } from '../../../type/never.type';
 import { ResultCallback } from '../../../type/result-callback.type';
 /**
- * Checks if a generic `Type` `value` is not a `function` type and not an instance of `Function`.
- * @param value A generic `Type` `value`, by default of type detected from the `value`, to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is not a `function`.
+ * Checks if the `value` is **not** the type obtained from its object class equal to `'function'`, **not** a `function` type and **not** an
+ * instance of `Function`.
+ * @param value The `value` of a generic type variable `Type`, by default of the type captured from itself to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of the generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is not a `function`.
+ * @angularpackage
  */
-export const isNotFunction: IsNotFunction = <Type>(
+export const isNotFunction = <Type, Payload extends object = object>(
   value: Type,
-  callback: ResultCallback = resultCallback
-): value is Never<Func, Type> =>
+  callback: ResultCallback<Type, Payload> = resultCallback,
+  payload?: Payload
+): value is Never<Function, Type> =>
   callback(
     typeOf(value) !== 'function' &&
-    typeof value !== 'function' &&
-    value instanceof Function === false,
-    value
+      typeof value !== 'function' &&
+      value instanceof Function === false,
+    value,
+    payload
   );
diff --git a/src/is/not/lib/is-not-null.func.ts b/src/is/not/lib/is-not-null.func.ts
index 6af18b29..ffb04d6c 100644
--- a/src/is/not/lib/is-not-null.func.ts
+++ b/src/is/not/lib/is-not-null.func.ts
@@ -2,17 +2,21 @@
 import { resultCallback } from '../../../lib/result-callback.func';
 import { typeOf } from '../../../lib/type-of.func';
 // Type.
-import { IsNotNull } from '../type/is-not-null.type';
 import { ResultCallback } from '../../../type/result-callback.type';
 import { Never } from '../../../type/never.type';
 /**
- * Checks if a generic `Type` `value` is not a `null` type and not equal to `null`.
- * @param value A generic `Type` `value`, by default of type detected from the `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is not `null`.
+ * Checks if the `value` is **not** the type obtained from its object class equal to `'null'` and **not** equal to `null`.
+ * @param value The `value` of a generic `Type`, by default of type captured from itself to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of the generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is not `null`.
+ * @angularpackage
  */
-export const isNotNull: IsNotNull = <Type>(
+export const isNotNull = <Type, Payload extends object = object>(
   value: Type,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<Type, Payload> = resultCallback,
+  payload?: Payload
 ): value is Never<null, Type> =>
-  callback(typeOf(value) !== 'null' && value !== null, value);
+  callback(typeOf(value) !== 'null' && value !== null, value, payload);
diff --git a/src/is/not/lib/is-not-number.func.ts b/src/is/not/lib/is-not-number.func.ts
index 771d75be..e0969e18 100644
--- a/src/is/not/lib/is-not-number.func.ts
+++ b/src/is/not/lib/is-not-number.func.ts
@@ -3,22 +3,28 @@ import { resultCallback } from '../../../lib/result-callback.func';
 import { typeOf } from '../../../lib/type-of.func';
 // Type.
 import { AnyNumber } from '../../../type/any-number.type';
-import { IsNotNumber } from '../type/is-not-number.type';
 import { Never } from '../../../type/never.type';
 import { ResultCallback } from '../../../type/result-callback.type';
 /**
- * Checks if a generic `Type` `value` is not a `number` type and not an instance of `Number`.
- * @param value A generic `Type`, by default of type detected from the `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is not a `number` or `Number` instance.
+ * Checks if the `value` is **not** the type obtained from its object class equal to `'number'`, **not** a `number` type and **not** an
+ * instance of `Number`.
+ * @param value The `value` of a generic type variable `Type`, by default of the type captured from itself to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of the generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is not a `number` type and not an instance of  `Number`.
+ * @angularpackage
  */
-export const isNotNumber: IsNotNumber = <Type>(
+export const isNotNumber = <Type, Payload extends object = object>(
   value: Type,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<Type, Payload> = resultCallback,
+  payload?: Payload
 ): value is Never<AnyNumber, Type> =>
   callback(
     typeOf(value) !== 'number' &&
-    typeof value !== 'number' &&
-    value instanceof Number === false,
-    value
+      typeof value !== 'number' &&
+      value instanceof Number === false,
+    value,
+    payload
   );
diff --git a/src/is/not/lib/is-not-string.func.ts b/src/is/not/lib/is-not-string.func.ts
index f0fb7f10..5795986b 100644
--- a/src/is/not/lib/is-not-string.func.ts
+++ b/src/is/not/lib/is-not-string.func.ts
@@ -3,22 +3,28 @@ import { resultCallback } from '../../../lib/result-callback.func';
 import { typeOf } from '../../../lib/type-of.func';
 // Type.
 import { AnyString } from '../../../type/any-string.type';
-import { IsNotString } from '../type/is-not-string.type';
 import { Never } from '../../../type/never.type';
 import { ResultCallback } from '../../../type/result-callback.type';
 /**
- * Checks if a generic `Type` `value` is not a `string` type and not an instance of `String`.
- * @param value A generic `Type`, by default of type detected from the `value` to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is not a `string` or `String` instance.
+ * Checks if the `value` is **not** the type obtained from its object class equal to `'string'`, **not** a `string` type and **not** an
+ * instance of `String`.
+ * @param value The `value` of a generic type variable `Type`, by default of the type captured from itself to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of the generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the provided `value` is not a `string` and not an instance of `String`.
+ * @angularpackage
  */
-export const isNotString: IsNotString = <Type>(
+export const isNotString = <Type, Payload extends object = object>(
   value: Type,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<Type, Payload> = resultCallback,
+  payload?: Payload
 ): value is Never<AnyString, Type> =>
   callback(
     typeOf(value) !== 'string' &&
-    typeof value !== 'string' &&
-    value instanceof String === false,
-    value
+      typeof value !== 'string' &&
+      value instanceof String === false,
+    value,
+    payload
   );
diff --git a/src/is/not/lib/is-not-undefined.func.ts b/src/is/not/lib/is-not-undefined.func.ts
index 3aafc7b7..8d2f004b 100644
--- a/src/is/not/lib/is-not-undefined.func.ts
+++ b/src/is/not/lib/is-not-undefined.func.ts
@@ -3,21 +3,26 @@ import { resultCallback } from '../../../lib/result-callback.func';
 import { typeOf } from '../../../lib/type-of.func';
 // Type.
 import { Defined } from '../../../type/defined.type';
-import { IsNotUndefined } from '../type/is-not-undefined.type';
 import { ResultCallback } from '../../../type/result-callback.type';
 /**
- * Checks if a generic `Type` `value` is not an `undefined` type and not equal to `undefined`.
- * @param value A generic `Type` `value`, by default of type detected from the `value`, to check.
- * @param callback A `ResultCallback` function to handle the result before returns.
- * @returns A `boolean` indicating whether or not the `value` is not `undefined`.
+ * Checks if the `value` is **not** the type obtained from its object class equal to `'undefined'`, **not** an `undefined` type and **not**
+ * equal to `undefined`.
+ * @param value The `value` of a generic type variable `Type`, by default of the type captured from itself to check.
+ * @param callback A callback `function` of `ResultCallback` type with parameters, the `value` that has been checked, the `result` of this
+ * check, and `payload` of the generic type variable `Payload` with optional properties from the provided `payload`, to handle them before
+ * the `result` return. By default, it uses `resultCallback()` function.
+ * @param payload An optional `object` of the generic type variable `Payload` is assigned to the `payload` of the given `callback` function.
+ * @returns The return value is a `boolean` indicating whether the `value` is not `undefined`.
  */
-export const isNotUndefined: IsNotUndefined = <Type>(
+export const isNotUndefined = <Type, Payload extends object = object>(
   value: Type,
-  callback: ResultCallback = resultCallback
+  callback: ResultCallback<Type, Payload> = resultCallback,
+  payload?: Payload
 ): value is Defined<Type> =>
   callback(
     typeOf(value) !== 'undefined' &&
-    typeof value !== 'undefined' &&
-    value !== undefined,
-    value
+      typeof value !== 'undefined' &&
+      value !== undefined,
+    value,
+    payload
   );
diff --git a/src/is/not/lib/is-not.object.ts b/src/is/not/lib/is-not.object.ts
index 71856213..4a666029 100644
--- a/src/is/not/lib/is-not.object.ts
+++ b/src/is/not/lib/is-not.object.ts
@@ -1,3 +1,4 @@
+// Function.
 import { IsNot } from '../interface/is-not.interface';
 import { isNotBoolean } from './is-not-boolean.func';
 import { isNotDefined } from './is-not-defined.func';
@@ -6,8 +7,10 @@ import { isNotNull } from './is-not-null.func';
 import { isNotNumber } from './is-not-number.func';
 import { isNotString } from './is-not-string.func';
 import { isNotUndefined } from './is-not-undefined.func';
-
-export const isNot: IsNot = {
+/**
+ * An `object` of `isNot` prefixed functions.
+ */
+export const isNot: IsNot = Object.freeze({
   // TODO array: isArray,
   // TODO bigInt: isBigInt,
   boolean: isNotBoolean,
@@ -21,4 +24,4 @@ export const isNot: IsNot = {
   // TODO symbol: isSymbol,
   // TODO type: isType,
   undefined: isNotUndefined
-};
+});
diff --git a/src/is/not/test/is-not-boolean.spec.ts b/src/is/not/test/is-not-boolean.spec.ts
index 2cc4484c..64d477ed 100644
--- a/src/is/not/test/is-not-boolean.spec.ts
+++ b/src/is/not/test/is-not-boolean.spec.ts
@@ -1,69 +1,84 @@
 // Function.
 import { isNotBoolean } from '../lib/is-not-boolean.func';
-// Constant.
-import { BIGINT, BIGINT_INSTANCE } from '../../../testing/src/big-int.const';
-import { Class, CLASS } from '../../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../../testing/src/boolean.const';
-import { FUNCTION } from '../../../testing/src/function.const';
-import { NULL } from '../../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO } from '../../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../../testing/src/symbol.const';
-import { UNDEFINED } from '../../../testing/src/undefined.const';
-import { notDefined } from '../../../testing/src/not-defined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe('isNotBoolean', () => {
-  // TRUE
-  it('is DEFINED', () => {
-    expect(isNotBoolean).toBeDefined();
-  });
-  // FALSE
-  it(`'bigint'`, () => {
-    expect(isNotBoolean(BIGINT)).toBeTrue();
-    expect(isNotBoolean(BIGINT_INSTANCE)).toBeTrue();
-  });
-  it(`Class | CLASS`, () => {
-    expect(isNotBoolean(Class)).toBeTrue();
-    expect(isNotBoolean(CLASS)).toBeTrue();
-  });
-  it(`'function' | Function`, () => {
-    expect(isNotBoolean(FUNCTION)).toBeTrue();
-  });
-  it(`null | NULL`, () => {
-    expect(isNotBoolean(null)).toBeTrue();
-    expect(isNotBoolean(NULL)).toBeTrue();
-  });
-  it(`'number' | Number`, () => {
-    expect(isNotBoolean(NUMBER)).toBeTrue();
-    expect(isNotBoolean(NUMBER_INSTANCE)).toBeTrue();
-    expect(isNotBoolean(NUMBER_NEW_INSTANCE)).toBeTrue();
-  });
-  it(`'object' | Object`, () => {
-    expect(isNotBoolean(OBJECT_ONE)).toBeTrue();
-    expect(isNotBoolean(OBJECT_TWO)).toBeTrue();
-  });
-  it(`'string' | String`, () => {
-    expect(isNotBoolean(STRING)).toBeTrue();
-    expect(isNotBoolean(STRING_INSTANCE)).toBeTrue();
-    expect(isNotBoolean(STRING_NEW_INSTANCE)).toBeTrue();
-  });
-  it(`'symbol'`, () => {
-    expect(isNotBoolean(SYMBOL_NUMBER)).toBeTrue();
-    expect(isNotBoolean(SYMBOL_STRING)).toBeTrue();
-  });
-  it(`'undefined'`, () => {
-    expect(isNotBoolean(notDefined)).toBeTrue();
-    expect(isNotBoolean(UNDEFINED)).toBeTrue();
-  });
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
-  // FALSE
-  it(`'boolean' | Boolean`, () => {
-    expect(isNotBoolean(FALSE)).toBeFalse();
-    expect(isNotBoolean(TRUE)).toBeFalse();
-    expect(isNotBoolean(FALSE_INSTANCE)).toBeFalse();
-    expect(isNotBoolean(TRUE_INSTANCE)).toBeFalse();
-    expect(isNotBoolean(Boolean(false))).toBeFalse();
-    expect(isNotBoolean(Boolean(true))).toBeFalse();
-  });
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.not.boolean.describe,
+  tests.is.not.boolean.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isNotBoolean.name, () => {
+  testing
+    // TRUE
+    .it('is DEFINED', () => expect(isNotBoolean).toBeDefined())
+    // FALSE
+    .it(`'bigint'`, () => expect(isNotBoolean(TESTING_BIGINT)).toBeTrue())
+    .it(`Class | CLASS`, () => {
+      expect(isNotBoolean(TestingClass)).toBeTrue();
+      expect(isNotBoolean(TESTING_CLASS)).toBeTrue();
+    })
+    .it(`'function' | Function`, () => expect(isNotBoolean(TESTING_FUNCTION)).toBeTrue())
+    .it(`null | NULL`, () => {
+      expect(isNotBoolean(null)).toBeTrue();
+      expect(isNotBoolean(TESTING_NULL)).toBeTrue();
+    })
+    .it(`'number' | Number`, () => {
+      expect(isNotBoolean(TESTING_NUMBER)).toBeTrue();
+      expect(isNotBoolean(TESTING_NUMBER_CONSTRUCTOR)).toBeTrue();
+      expect(isNotBoolean(TESTING_NUMBER_INSTANCE)).toBeTrue();
+    })
+    .it(`'object' | Object`, () => expect(isNotBoolean(TESTING_OBJECT)).toBeTrue())
+    .it(`'string' | String`, () => {
+      expect(isNotBoolean(TESTING_STRING)).toBeTrue();
+      expect(isNotBoolean(TESTING_STRING_CONSTRUCTOR)).toBeTrue();
+      expect(isNotBoolean(TESTING_STRING_INSTANCE)).toBeTrue();
+    })
+    .it(`'symbol'`, () => {
+      expect(isNotBoolean(TESTING_SYMBOL_NUMBER)).toBeTrue();
+      expect(isNotBoolean(TESTING_SYMBOL_STRING)).toBeTrue();
+    })
+    .it(`'undefined'`, () => expect(isNotBoolean(TESTING_UNDEFINED)).toBeTrue())
+
+    // FALSE
+    .it(`'boolean' | Boolean`, () => {
+      expect(isNotBoolean(TESTING_FALSE)).toBeFalse();
+      expect(isNotBoolean(TESTING_TRUE)).toBeFalse();
+      expect(isNotBoolean(TESTING_FALSE_INSTANCE)).toBeFalse();
+      expect(isNotBoolean(TESTING_TRUE_INSTANCE)).toBeFalse();
+      expect(isNotBoolean(Boolean(false))).toBeFalse();
+      expect(isNotBoolean(Boolean(true))).toBeFalse();
+    });
 });
diff --git a/src/is/not/test/is-not-defined.spec.ts b/src/is/not/test/is-not-defined.spec.ts
new file mode 100644
index 00000000..7093cce3
--- /dev/null
+++ b/src/is/not/test/is-not-defined.spec.ts
@@ -0,0 +1,117 @@
+// Function.
+import { isNotDefined } from '../lib/is-not-defined.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.not.defined.describe,
+  tests.is.not.defined.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isNotDefined.name, () => {
+  testing
+  // Defined.
+  .it('is DEFINED', () => expect(isNotDefined).toBeDefined())
+
+  // Checks ...
+  .describe(`checks`, () => {
+    testing
+    .it('callback', () => {
+      isNotDefined(TESTING_STRING, (result: boolean) => {
+        expect(result).toBeFalse();
+        return result;
+      });
+    })
+
+    // ... arrays.
+    .describe(`array`, () => {
+    })
+    // ... function.
+    .describe(`function`, () => {
+      testing
+      .it(`FUNCTION`, () => expect(isNotDefined(TESTING_FUNCTION)).toBeFalse())
+      .it(`Class`, () => expect(isNotDefined(TestingClass)).toBeFalse());
+    })
+    // ... objects.
+    .describe('object', () => {
+      testing
+      .it(`CLASS`, () => expect(isNotDefined(TESTING_CLASS)).toBeFalse())
+      .it(`OBJECT_ONE`, () => expect(isNotDefined(TESTING_OBJECT)).toBeFalse());
+    })
+    // ... primitives.
+    .describe(`primitive`, () => {
+      testing
+      // bigint
+      .describe(`bigint`, () => {
+        testing.it(`${TESTING_BIGINT}`, () => expect(isNotDefined(TESTING_BIGINT)).toBeFalse());
+      })
+
+      // boolean
+      .describe(`boolean`, () => {
+        testing
+        .it(`${TESTING_TRUE}`, () => expect(isNotDefined(TESTING_TRUE)).toBeFalse())
+        .it(`${TESTING_FALSE}`, () => expect(isNotDefined(TESTING_FALSE)).toBeFalse())
+        .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isNotDefined(TESTING_TRUE_INSTANCE)).toBeFalse())
+        .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isNotDefined(TESTING_FALSE_INSTANCE)).toBeFalse());
+      })
+
+      // null
+      .it(`${TESTING_NULL}`, () => expect(isNotDefined(TESTING_NULL)).toBeFalse())
+
+      // number
+      .describe(`number`, () => {
+        testing
+        .it(`${TESTING_NUMBER}`, () => expect(isNotDefined(TESTING_NUMBER)).toBeFalse())
+        .it(`Number(${TESTING_NUMBER})`, () => expect(isNotDefined(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse())
+        .it(`new Number(${TESTING_NUMBER})`, () => expect(isNotDefined(TESTING_NUMBER_INSTANCE)).toBeFalse());
+      })
+      // string
+      .describe(`string`, () => {
+        testing
+        .it(`${TESTING_STRING}`, () => expect(isNotDefined(TESTING_STRING)).toBeFalse())
+        .it(`String(${TESTING_STRING})`, () => expect(isNotDefined(TESTING_STRING_CONSTRUCTOR)).toBeFalse())
+        .it(`new String(${TESTING_STRING})`, () => expect(isNotDefined(TESTING_STRING_INSTANCE)).toBeFalse());
+      })
+      // symbol
+      .describe(`symbol`, () => {
+        testing
+        .it(`Symbol(${TESTING_NUMBER})`, () => expect(isNotDefined(TESTING_SYMBOL_NUMBER)).toBeFalse())
+        .it(`Symbol(${TESTING_STRING})`, () => expect(isNotDefined(TESTING_SYMBOL_STRING)).toBeFalse());
+      })
+      // undefined
+      .it(`${TESTING_UNDEFINED}`, () => expect(isNotDefined(TESTING_UNDEFINED)).toBeTrue());
+    });
+  });
+});
diff --git a/src/is/not/test/is-not-function.spec.ts b/src/is/not/test/is-not-function.spec.ts
index 09fd27da..30f94f7d 100644
--- a/src/is/not/test/is-not-function.spec.ts
+++ b/src/is/not/test/is-not-function.spec.ts
@@ -1,91 +1,116 @@
 // Function.
 import { isNotFunction } from '../lib/is-not-function.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../../testing/src/big-int.const';
-import { Class, CLASS } from '../../../testing/src/class.const';
-import { FUNCTION } from '../../../testing/src/function.const';
-import { NULL } from '../../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../../testing/src/symbol.const';
-import { TRUE, TRUE_EXPECTATION, FALSE, TRUE_INSTANCE, FALSE_EXPECTATION, FALSE_INSTANCE } from '../../../testing/src/boolean.const';
-import { UNDEFINED } from '../../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.not.function.describe,
+  tests.is.not.function.it
+);
 /**
- * Checks
- * ✓ typeOf() = 'function
- * ✓ typeof !== 'function'
- * ✓ instanceof Function === false
+ * Tests.
  */
-describe(`isNotFunction`, () => {
+testing.describe(isNotFunction.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(isNotFunction).toBeDefined());
+  .it('is DEFINED', () => expect(isNotFunction).toBeDefined())
 
   // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isNotFunction(STRING, (result: boolean) => {
-        expect(result).toBe(TRUE);
+  .describe(`checks`, () => {
+    testing
+    .it('callback', () => {
+      isNotFunction(TESTING_STRING, (result: boolean) => {
+        expect(result).toBe(TESTING_TRUE);
         return result;
       });
-    });
-
+    })
     // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isNotFunction(FUNCTION, 'function')).toBe(TRUE));
-      // it(`${Class}`, () => expect(isNotFunction(Class, 'function')).toBe(TRUE));
-    });
+    .describe(`array`, () => { })
     // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isNotFunction(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isNotFunction(Class)).toBe(FALSE));
-    });
+    .describe(`function`, () => {
+      testing
+      .it(`FUNCTION`, () => expect(isNotFunction(TESTING_FUNCTION)).toBe(TESTING_FALSE))
+      .it(`Class`, () => expect(isNotFunction(TestingClass)).toBe(TESTING_FALSE));
+    })
     // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isNotFunction(CLASS)).toBe(TRUE));
-      it(`OBJECT_ONE`, () => expect(isNotFunction(OBJECT_ONE)).toBe(TRUE));
-      it(`OBJECT_TWO`, () => expect(isNotFunction(OBJECT_TWO)).toBe(TRUE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isNotFunction(OBJECT_ONE_NEW)).toBe(TRUE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isNotFunction(OBJECT_TWO_NEW)).toBe(TRUE));
-    });
+    .describe('object', () => {
+      testing
+      .it(`CLASS`, () => expect(isNotFunction(TESTING_CLASS)).toBe(TESTING_TRUE))
+      .it(`OBJECT_ONE`, () => expect(isNotFunction(TESTING_OBJECT)).toBe(TESTING_TRUE));
+    })
     // ... primitives.
-    describe(`primitive`, () => {
+    .describe(`primitive`, () => {
+      testing
       // bigint
-      describe(`bigint`, () => {
-        it(`${BIGINT}`, () => expect(isNotFunction(BIGINT)).toBe(TRUE));
-        it(`${BIGINT_EXPECTATION}`, () => expect(isNotFunction(BIGINT_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`bigint`, () => {
+        testing
+        .it(`${TESTING_BIGINT}`, () => expect(isNotFunction(TESTING_BIGINT)).toBe(TESTING_TRUE));
+      })
 
       // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isNotFunction(TRUE)).toBe(TRUE));
-        it(`${FALSE}`, () => expect(isNotFunction(FALSE)).toBe(TRUE));
-        it(`${TRUE_EXPECTATION}`, () => expect(isNotFunction(TRUE_INSTANCE)).toBe(TRUE));
-        it(`${FALSE_EXPECTATION}`, () => expect(isNotFunction(FALSE_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`boolean`, () => {
+        testing
+        .it(`${TESTING_TRUE}`, () => expect(isNotFunction(TESTING_TRUE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_FALSE}`, () => expect(isNotFunction(TESTING_FALSE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isNotFunction(TESTING_TRUE_INSTANCE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isNotFunction(TESTING_FALSE_INSTANCE)).toBe(TESTING_TRUE));
+      })
 
       // null
-      it(`${NULL}`, () => expect(isNotFunction(NULL)).toBe(TRUE));
+      .it(`${TESTING_NULL}`, () => expect(isNotFunction(TESTING_NULL)).toBe(TESTING_TRUE))
 
       // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isNotFunction(NUMBER)).toBe(TRUE));
-        it(`Number(${NUMBER})`, () => expect(isNotFunction(NUMBER_INSTANCE)).toBe(TRUE));
-        it(`new Number(${NUMBER})`, () => expect(isNotFunction(NUMBER_NEW_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`number`, () => {
+        testing
+        .it(`${TESTING_NUMBER}`, () => expect(isNotFunction(TESTING_NUMBER)).toBe(TESTING_TRUE))
+        .it(`Number(${TESTING_NUMBER})`, () => expect(isNotFunction(TESTING_NUMBER_CONSTRUCTOR)).toBe(TESTING_TRUE))
+        .it(`new Number(${TESTING_NUMBER})`, () => expect(isNotFunction(TESTING_NUMBER_INSTANCE)).toBe(TESTING_TRUE));
+      })
       // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isNotFunction(STRING)).toBe(TRUE));
-        it(`String(${STRING})`, () => expect(isNotFunction(STRING_INSTANCE)).toBe(TRUE));
-        it(`new String(${STRING})`, () => expect(isNotFunction(STRING_NEW_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`string`, () => {
+        testing
+        .it(`${TESTING_STRING}`, () => expect(isNotFunction(TESTING_STRING)).toBe(TESTING_TRUE))
+        .it(`String(${TESTING_STRING})`, () => expect(isNotFunction(TESTING_STRING_CONSTRUCTOR)).toBe(TESTING_TRUE))
+        .it(`new String(${TESTING_STRING})`, () => expect(isNotFunction(TESTING_STRING_INSTANCE)).toBe(TESTING_TRUE));
+      })
       // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isNotFunction(SYMBOL_NUMBER)).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(isNotFunction(SYMBOL_STRING)).toBe(TRUE));
-      });
+      .describe(`symbol`, () => {
+        testing
+        .it(`Symbol(${TESTING_NUMBER})`, () => expect(isNotFunction(TESTING_SYMBOL_NUMBER)).toBe(TESTING_TRUE))
+        .it(`Symbol(${TESTING_STRING})`, () => expect(isNotFunction(TESTING_SYMBOL_STRING)).toBe(TESTING_TRUE));
+      })
       // undefined
-      it(`${UNDEFINED}`, () => expect(isNotFunction(UNDEFINED)).toBe(TRUE));
+      .it(`${TESTING_UNDEFINED}`, () => expect(isNotFunction(TESTING_UNDEFINED)).toBe(TESTING_TRUE));
     });
   });
 });
diff --git a/src/is/not/test/is-not-null.spec.ts b/src/is/not/test/is-not-null.spec.ts
index 019bf6db..4d657550 100644
--- a/src/is/not/test/is-not-null.spec.ts
+++ b/src/is/not/test/is-not-null.spec.ts
@@ -1,90 +1,115 @@
 // Function.
 import { isNotNull } from '../lib/is-not-null.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../../testing/src/big-int.const';
-import { Class, CLASS } from '../../../testing/src/class.const';
-import { FUNCTION } from '../../../testing/src/function.const';
-import { NULL } from '../../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../../testing/src/symbol.const';
-import { TRUE, TRUE_EXPECTATION, FALSE, TRUE_INSTANCE, FALSE_EXPECTATION, FALSE_INSTANCE } from '../../../testing/src/boolean.const';
-import { UNDEFINED } from '../../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.not.null.describe,
+  tests.is.not.null.it
+);
 /**
- * Checks
- * ✓ typeOf() = 'null
- * ✓ value !== null
+ * Tests.
  */
-describe(`isNotNull`, () => {
+testing.describe(isNotNull.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(isNotNull).toBeDefined());
+  .it('is DEFINED', () => expect(isNotNull).toBeDefined())
 
   // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isNotNull(STRING, (result: boolean) => {
-        expect(result).toBe(TRUE);
+  .describe(`checks`, () => {
+    testing
+    .it('callback', () => {
+      isNotNull(TESTING_STRING, (result: boolean) => {
+        expect(result).toBe(TESTING_TRUE);
         return result;
       });
-    });
+    })
 
     // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isNotNull(FUNCTION, 'function')).toBe(TRUE));
-      // it(`${Class}`, () => expect(isNotNull(Class, 'function')).toBe(TRUE));
-    });
+    .describe(`array`, () => { })
     // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isNotNull(FUNCTION)).toBe(TRUE));
-      it(`Class`, () => expect(isNotNull(Class)).toBe(TRUE));
-    });
+    .describe(`function`, () => {
+      testing
+      .it(`FUNCTION`, () => expect(isNotNull(TESTING_FUNCTION)).toBe(TESTING_TRUE))
+      .it(`Class`, () => expect(isNotNull(TestingClass)).toBe(TESTING_TRUE));
+    })
     // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isNotNull(CLASS)).toBe(TRUE));
-      it(`OBJECT_ONE`, () => expect(isNotNull(OBJECT_ONE)).toBe(TRUE));
-      it(`OBJECT_TWO`, () => expect(isNotNull(OBJECT_TWO)).toBe(TRUE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isNotNull(OBJECT_ONE_NEW)).toBe(TRUE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isNotNull(OBJECT_TWO_NEW)).toBe(TRUE));
-    });
+    .describe('object', () => {
+      testing
+      .it(`CLASS`, () => expect(isNotNull(TESTING_CLASS)).toBe(TESTING_TRUE))
+      .it(`OBJECT_ONE`, () => expect(isNotNull(TESTING_OBJECT)).toBe(TESTING_TRUE));
+    })
     // ... primitives.
-    describe(`primitive`, () => {
+    .describe(`primitive`, () => {
+      testing
       // bigint
-      describe(`bigint`, () => {
-        it(`${BIGINT}`, () => expect(isNotNull(BIGINT)).toBe(TRUE));
-        it(`${BIGINT_EXPECTATION}`, () => expect(isNotNull(BIGINT_INSTANCE)).toBe(TRUE));
-      });
-
+      .describe(`bigint`, () => {
+        testing.it(`${TESTING_BIGINT}`, () => expect(isNotNull(TESTING_BIGINT)).toBe(TESTING_TRUE));
+      })
       // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isNotNull(TRUE)).toBe(TRUE));
-        it(`${FALSE}`, () => expect(isNotNull(FALSE)).toBe(TRUE));
-        it(`${TRUE_EXPECTATION}`, () => expect(isNotNull(TRUE_INSTANCE)).toBe(TRUE));
-        it(`${FALSE_EXPECTATION}`, () => expect(isNotNull(FALSE_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`boolean`, () => {
+        testing
+        .it(`${TESTING_TRUE}`, () => expect(isNotNull(TESTING_TRUE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_FALSE}`, () => expect(isNotNull(TESTING_FALSE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isNotNull(TESTING_TRUE_INSTANCE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isNotNull(TESTING_FALSE_INSTANCE)).toBe(TESTING_TRUE));
+      })
 
       // null
-      it(`${NULL}`, () => expect(isNotNull(NULL)).toBe(FALSE));
+      .it(`${TESTING_NULL}`, () => expect(isNotNull(TESTING_NULL)).toBe(TESTING_FALSE))
 
       // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isNotNull(NUMBER)).toBe(TRUE));
-        it(`Number(${NUMBER})`, () => expect(isNotNull(NUMBER_INSTANCE)).toBe(TRUE));
-        it(`new Number(${NUMBER})`, () => expect(isNotNull(NUMBER_NEW_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`number`, () => {
+        testing
+        .it(`${TESTING_NUMBER}`, () => expect(isNotNull(TESTING_NUMBER)).toBe(TESTING_TRUE))
+        .it(`Number(${TESTING_NUMBER})`, () => expect(isNotNull(TESTING_NUMBER_CONSTRUCTOR)).toBe(TESTING_TRUE))
+        .it(`new Number(${TESTING_NUMBER})`, () => expect(isNotNull(TESTING_NUMBER_INSTANCE)).toBe(TESTING_TRUE));
+      })
       // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isNotNull(STRING)).toBe(TRUE));
-        it(`String(${STRING})`, () => expect(isNotNull(STRING_INSTANCE)).toBe(TRUE));
-        it(`new String(${STRING})`, () => expect(isNotNull(STRING_NEW_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`string`, () => {
+        testing
+        .it(`${TESTING_STRING}`, () => expect(isNotNull(TESTING_STRING)).toBe(TESTING_TRUE))
+        .it(`String(${TESTING_STRING})`, () => expect(isNotNull(TESTING_STRING_CONSTRUCTOR)).toBe(TESTING_TRUE))
+        .it(`new String(${TESTING_STRING})`, () => expect(isNotNull(TESTING_STRING_INSTANCE)).toBe(TESTING_TRUE));
+      })
       // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isNotNull(SYMBOL_NUMBER)).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(isNotNull(SYMBOL_STRING)).toBe(TRUE));
-      });
+      .describe(`symbol`, () => {
+        testing
+        .it(`Symbol(${TESTING_NUMBER})`, () => expect(isNotNull(TESTING_SYMBOL_NUMBER)).toBe(TESTING_TRUE))
+        .it(`Symbol(${TESTING_STRING})`, () => expect(isNotNull(TESTING_SYMBOL_STRING)).toBe(TESTING_TRUE));
+      })
       // undefined
-      it(`${UNDEFINED}`, () => expect(isNotNull(UNDEFINED)).toBe(TRUE));
+      .it(`${TESTING_UNDEFINED}`, () => expect(isNotNull(TESTING_UNDEFINED)).toBe(TESTING_TRUE));
     });
   });
 });
diff --git a/src/is/not/test/is-not-number.spec.ts b/src/is/not/test/is-not-number.spec.ts
index 628ff98c..f0e1883c 100644
--- a/src/is/not/test/is-not-number.spec.ts
+++ b/src/is/not/test/is-not-number.spec.ts
@@ -1,91 +1,116 @@
 // Function.
 import { isNotNumber } from '../lib/is-not-number.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../../testing/src/big-int.const';
-import { Class, CLASS } from '../../../testing/src/class.const';
-import { FUNCTION } from '../../../testing/src/function.const';
-import { NULL } from '../../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../../testing/src/symbol.const';
-import { TRUE, TRUE_EXPECTATION, FALSE, TRUE_INSTANCE, FALSE_INSTANCE, FALSE_EXPECTATION } from '../../../testing/src/boolean.const';
-import { UNDEFINED } from '../../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.not.number.describe,
+  tests.is.not.number.it
+);
 /**
- * Checks
- * ✓ typeOf() = 'number
- * ✓ typeof !== 'number'
- * ✓ instanceof Number === false
+ * Tests.
  */
-describe(`isNotNumber`, () => {
+testing.describe(isNotNumber.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(isNotNumber).toBeDefined());
+  .it('is DEFINED', () => expect(isNotNumber).toBeDefined())
 
   // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isNotNumber(STRING, (result: boolean) => {
-        expect(result).toBe(TRUE);
+  .describe(`checks`, () => {
+    testing
+    .it('callback', () => {
+      isNotNumber(TESTING_STRING, (result: boolean) => {
+        expect(result).toBe(TESTING_TRUE);
         return result;
       });
-    });
+    })
 
     // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isNotNumber(FUNCTION, 'function')).toBe(TRUE));
-      // it(`${Class}`, () => expect(isNotNumber(Class, 'function')).toBe(TRUE));
-    });
+    .describe(`array`, () => { })
     // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isNotNumber(FUNCTION)).toBe(TRUE));
-      it(`Class`, () => expect(isNotNumber(Class)).toBe(TRUE));
-    });
+    .describe(`function`, () => {
+      testing
+      .it(`FUNCTION`, () => expect(isNotNumber(TESTING_FUNCTION)).toBe(TESTING_TRUE))
+      .it(`Class`, () => expect(isNotNumber(TestingClass)).toBe(TESTING_TRUE));
+    })
     // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isNotNumber(CLASS)).toBe(TRUE));
-      it(`OBJECT_ONE`, () => expect(isNotNumber(OBJECT_ONE)).toBe(TRUE));
-      it(`OBJECT_TWO`, () => expect(isNotNumber(OBJECT_TWO)).toBe(TRUE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isNotNumber(OBJECT_ONE_NEW)).toBe(TRUE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isNotNumber(OBJECT_TWO_NEW)).toBe(TRUE));
-    });
+    .describe('object', () => {
+      testing
+      .it(`CLASS`, () => expect(isNotNumber(TESTING_CLASS)).toBe(TESTING_TRUE))
+      .it(`OBJECT_ONE`, () => expect(isNotNumber(TESTING_OBJECT)).toBe(TESTING_TRUE));
+    })
     // ... primitives.
-    describe(`primitive`, () => {
+    .describe(`primitive`, () => {
+      testing
       // bigint
-      describe(`bigint`, () => {
-        it(`${BIGINT}`, () => expect(isNotNumber(BIGINT)).toBe(TRUE));
-        it(`${BIGINT_EXPECTATION}`, () => expect(isNotNumber(BIGINT_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`bigint`, () => {
+        testing.it(`${TESTING_BIGINT}`, () => expect(isNotNumber(TESTING_BIGINT)).toBe(TESTING_TRUE));
+      })
 
       // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isNotNumber(TRUE)).toBe(TRUE));
-        it(`${FALSE}`, () => expect(isNotNumber(FALSE)).toBe(TRUE));
-        it(`${TRUE_EXPECTATION}`, () => expect(isNotNumber(TRUE_INSTANCE)).toBe(TRUE));
-        it(`${FALSE_EXPECTATION}`, () => expect(isNotNumber(FALSE_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`boolean`, () => {
+        testing
+        .it(`${TESTING_TRUE}`, () => expect(isNotNumber(TESTING_TRUE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_FALSE}`, () => expect(isNotNumber(TESTING_FALSE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isNotNumber(TESTING_TRUE_INSTANCE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isNotNumber(TESTING_FALSE_INSTANCE)).toBe(TESTING_TRUE));
+      })
 
       // null
-      it(`${NULL}`, () => expect(isNotNumber(NULL)).toBe(TRUE));
+      .it(`${TESTING_NULL}`, () => expect(isNotNumber(TESTING_NULL)).toBe(TESTING_TRUE))
 
       // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isNotNumber(NUMBER)).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isNotNumber(NUMBER_INSTANCE)).toBe(FALSE));
-        it(`new Number(${NUMBER})`, () => expect(isNotNumber(NUMBER_NEW_INSTANCE)).toBe(FALSE));
-      });
+      .describe(`number`, () => {
+        testing
+        .it(`${TESTING_NUMBER}`, () => expect(isNotNumber(TESTING_NUMBER)).toBe(TESTING_FALSE))
+        .it(`Number(${TESTING_NUMBER})`, () => expect(isNotNumber(TESTING_NUMBER_CONSTRUCTOR)).toBe(TESTING_FALSE))
+        .it(`new Number(${TESTING_NUMBER})`, () => expect(isNotNumber(TESTING_NUMBER_INSTANCE)).toBe(TESTING_FALSE));
+      })
       // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isNotNumber(STRING)).toBe(TRUE));
-        it(`String(${STRING})`, () => expect(isNotNumber(STRING_INSTANCE)).toBe(TRUE));
-        it(`new String(${STRING})`, () => expect(isNotNumber(STRING_NEW_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`string`, () => {
+        testing
+        .it(`${TESTING_STRING}`, () => expect(isNotNumber(TESTING_STRING)).toBe(TESTING_TRUE))
+        .it(`String(${TESTING_STRING})`, () => expect(isNotNumber(TESTING_STRING_CONSTRUCTOR)).toBe(TESTING_TRUE))
+        .it(`new String(${TESTING_STRING})`, () => expect(isNotNumber(TESTING_STRING_INSTANCE)).toBe(TESTING_TRUE));
+      })
       // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isNotNumber(SYMBOL_NUMBER)).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(isNotNumber(SYMBOL_STRING)).toBe(TRUE));
-      });
+      .describe(`symbol`, () => {
+        testing
+        .it(`Symbol(${TESTING_NUMBER})`, () => expect(isNotNumber(TESTING_SYMBOL_NUMBER)).toBe(TESTING_TRUE))
+        .it(`Symbol(${TESTING_STRING})`, () => expect(isNotNumber(TESTING_SYMBOL_STRING)).toBe(TESTING_TRUE));
+      })
       // undefined
-      it(`${UNDEFINED}`, () => expect(isNotNumber(UNDEFINED)).toBe(TRUE));
+      .it(`${TESTING_UNDEFINED}`, () => expect(isNotNumber(TESTING_UNDEFINED)).toBe(TESTING_TRUE));
     });
   });
 });
diff --git a/src/is/not/test/is-not-string.spec.ts b/src/is/not/test/is-not-string.spec.ts
index 2cc4c434..6b10897b 100644
--- a/src/is/not/test/is-not-string.spec.ts
+++ b/src/is/not/test/is-not-string.spec.ts
@@ -1,91 +1,114 @@
 // Function.
 import { isNotString } from '../lib/is-not-string.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../../testing/src/big-int.const';
-import { Class, CLASS } from '../../../testing/src/class.const';
-import { FUNCTION } from '../../../testing/src/function.const';
-import { NULL } from '../../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../../testing/src/symbol.const';
-import { TRUE, TRUE_EXPECTATION, FALSE, TRUE_INSTANCE, FALSE_EXPECTATION, FALSE_INSTANCE } from '../../../testing/src/boolean.const';
-import { UNDEFINED } from '../../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.not.string.describe,
+  tests.is.not.string.it
+);
 /**
- * Checks
- * ✓ typeOf() = 'string
- * ✓ typeof !== 'string'
- * ✓ instanceof String === false
+ * Tests.
  */
-describe(`isNotString`, () => {
+testing.describe(isNotString.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(isNotString).toBeDefined());
+  .it('is DEFINED', () => expect(isNotString).toBeDefined())
 
   // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isNotString(STRING, (result: boolean) => {
-        expect(result).toBe(FALSE);
+  .describe(`checks`, () => {
+    testing
+    .it('callback', () => {
+      isNotString(TESTING_STRING, (result: boolean) => {
+        expect(result).toBe(TESTING_FALSE);
         return result;
       });
-    });
+    })
 
     // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isNotString(FUNCTION, 'function')).toBe(TRUE));
-      // it(`${Class}`, () => expect(isNotString(Class, 'function')).toBe(TRUE));
-    });
+    .describe(`array`, () => {})
     // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isNotString(FUNCTION)).toBe(TRUE));
-      it(`Class`, () => expect(isNotString(Class)).toBe(TRUE));
-    });
+    .describe(`function`, () => {
+      testing
+      .it(`FUNCTION`, () => expect(isNotString(TESTING_FUNCTION)).toBe(TESTING_TRUE))
+      .it(`Class`, () => expect(isNotString(TestingClass)).toBe(TESTING_TRUE));
+    })
     // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isNotString(CLASS)).toBe(TRUE));
-      it(`OBJECT_ONE`, () => expect(isNotString(OBJECT_ONE)).toBe(TRUE));
-      it(`OBJECT_TWO`, () => expect(isNotString(OBJECT_TWO)).toBe(TRUE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isNotString(OBJECT_ONE_NEW)).toBe(TRUE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isNotString(OBJECT_TWO_NEW)).toBe(TRUE));
-    });
+    .describe('object', () => {
+      testing
+      .it(`CLASS`, () => expect(isNotString(TESTING_CLASS)).toBe(TESTING_TRUE))
+      .it(`OBJECT_ONE`, () => expect(isNotString(TESTING_OBJECT)).toBe(TESTING_TRUE));
+    })
     // ... primitives.
-    describe(`primitive`, () => {
+    .describe(`primitive`, () => {
+      testing
       // bigint
-      describe(`bigint`, () => {
-        it(`${BIGINT}`, () => expect(isNotString(BIGINT)).toBe(TRUE));
-        it(`${BIGINT_EXPECTATION}`, () => expect(isNotString(BIGINT_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`bigint`, () => it(`${TESTING_BIGINT}`, () => expect(isNotString(TESTING_BIGINT)).toBe(TESTING_TRUE)))
 
       // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isNotString(TRUE)).toBe(TRUE));
-        it(`${FALSE}`, () => expect(isNotString(FALSE)).toBe(TRUE));
-        it(`${TRUE_EXPECTATION}`, () => expect(isNotString(TRUE_INSTANCE)).toBe(TRUE));
-        it(`${FALSE_EXPECTATION}`, () => expect(isNotString(FALSE_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`boolean`, () => {
+        testing
+        .it(`${TESTING_TRUE}`, () => expect(isNotString(TESTING_TRUE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_FALSE}`, () => expect(isNotString(TESTING_FALSE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isNotString(TESTING_TRUE_INSTANCE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isNotString(TESTING_FALSE_INSTANCE)).toBe(TESTING_TRUE));
+      })
 
       // null
-      it(`${NULL}`, () => expect(isNotString(NULL)).toBe(TRUE));
+      .it(`${TESTING_NULL}`, () => expect(isNotString(TESTING_NULL)).toBe(TESTING_TRUE))
 
       // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isNotString(NUMBER)).toBe(TRUE));
-        it(`Number(${NUMBER})`, () => expect(isNotString(NUMBER_INSTANCE)).toBe(TRUE));
-        it(`new Number(${NUMBER})`, () => expect(isNotString(NUMBER_NEW_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`number`, () => {
+        testing
+        .it(`${TESTING_NUMBER}`, () => expect(isNotString(TESTING_NUMBER)).toBe(TESTING_TRUE))
+        .it(`Number(${TESTING_NUMBER})`, () => expect(isNotString(TESTING_NUMBER_CONSTRUCTOR)).toBe(TESTING_TRUE))
+        .it(`new Number(${TESTING_NUMBER})`, () => expect(isNotString(TESTING_NUMBER_INSTANCE)).toBe(TESTING_TRUE));
+      })
       // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isNotString(STRING)).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isNotString(STRING_INSTANCE)).toBe(FALSE));
-        it(`new String(${STRING})`, () => expect(isNotString(STRING_NEW_INSTANCE)).toBe(FALSE));
-      });
+      .describe(`string`, () => {
+        testing
+        .it(`${TESTING_STRING}`, () => expect(isNotString(TESTING_STRING)).toBe(TESTING_FALSE))
+        .it(`String(${TESTING_STRING})`, () => expect(isNotString(TESTING_STRING_CONSTRUCTOR)).toBe(TESTING_FALSE))
+        .it(`new String(${TESTING_STRING})`, () => expect(isNotString(TESTING_STRING_INSTANCE)).toBe(TESTING_FALSE));
+      })
       // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isNotString(SYMBOL_NUMBER)).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(isNotString(SYMBOL_STRING)).toBe(TRUE));
-      });
+      .describe(`symbol`, () => {
+        testing
+        .it(`Symbol(${TESTING_NUMBER})`, () => expect(isNotString(TESTING_SYMBOL_NUMBER)).toBe(TESTING_TRUE))
+        .it(`Symbol(${TESTING_STRING})`, () => expect(isNotString(TESTING_SYMBOL_STRING)).toBe(TESTING_TRUE));
+      })
       // undefined
-      it(`${UNDEFINED}`, () => expect(isNotString(UNDEFINED)).toBe(TRUE));
+      .it(`${TESTING_UNDEFINED}`, () => expect(isNotString(TESTING_UNDEFINED)).toBe(TESTING_TRUE));
     });
   });
 });
diff --git a/src/is/not/test/is-not-undefined.spec.ts b/src/is/not/test/is-not-undefined.spec.ts
index 83c2d466..9f312535 100644
--- a/src/is/not/test/is-not-undefined.spec.ts
+++ b/src/is/not/test/is-not-undefined.spec.ts
@@ -1,91 +1,115 @@
 // Function.
 import { isNotUndefined } from '../lib/is-not-undefined.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../../testing/src/big-int.const';
-import { Class, CLASS } from '../../../testing/src/class.const';
-import { FUNCTION } from '../../../testing/src/function.const';
-import { NULL } from '../../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../../testing/src/symbol.const';
-import { TRUE, TRUE_EXPECTATION, FALSE, TRUE_INSTANCE } from '../../../testing/src/boolean.const';
-import { UNDEFINED } from '../../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.not.undefined.describe,
+  tests.is.not.undefined.it
+);
 /**
- * Checks
- * ✓ typeOf() = 'undefined
- * ✓ typeof === 'undefined'
- * ✓ value === undefined
+ * Tests.
  */
-describe(`isNotUndefined`, () => {
+testing.describe(isNotUndefined.name, () => {
+  testing
   // Defined.
-  it('is DEFINED', () => expect(isNotUndefined).toBeDefined());
+  .it('is DEFINED', () => expect(isNotUndefined).toBeDefined())
 
   // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isNotUndefined(STRING, (result: boolean) => {
-        expect(result).toBe(TRUE);
+  .describe(`checks`, () => {
+    testing
+    .it('callback', () => {
+      isNotUndefined(TESTING_STRING, (result: boolean) => {
+        expect(result).toBe(TESTING_TRUE);
         return result;
       });
-    });
+    })
 
     // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isNotUndefined(FUNCTION, 'function')).toBe(TRUE));
-      // it(`${Class}`, () => expect(isNotUndefined(Class, 'function')).toBe(TRUE));
-    });
+    .describe(`array`, () => {})
     // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isNotUndefined(FUNCTION)).toBe(TRUE));
-      it(`Class`, () => expect(isNotUndefined(Class)).toBe(TRUE));
-    });
+    .describe(`function`, () => {
+      testing
+      .it(`FUNCTION`, () => expect(isNotUndefined(TESTING_FUNCTION)).toBe(TESTING_TRUE))
+      .it(`Class`, () => expect(isNotUndefined(TestingClass)).toBe(TESTING_TRUE));
+    })
     // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isNotUndefined(CLASS)).toBe(TRUE));
-      it(`OBJECT_ONE`, () => expect(isNotUndefined(OBJECT_ONE)).toBe(TRUE));
-      it(`OBJECT_TWO`, () => expect(isNotUndefined(OBJECT_TWO)).toBe(TRUE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isNotUndefined(OBJECT_ONE_NEW)).toBe(TRUE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isNotUndefined(OBJECT_TWO_NEW)).toBe(TRUE));
-    });
+    .describe('object', () => {
+      testing
+      .it(`CLASS`, () => expect(isNotUndefined(TESTING_CLASS)).toBe(TESTING_TRUE))
+      .it(`OBJECT_ONE`, () => expect(isNotUndefined(TESTING_OBJECT)).toBe(TESTING_TRUE));
+    })
     // ... primitives.
-    describe(`primitive`, () => {
+    .describe(`primitive`, () => {
+      testing
       // bigint
-      describe(`bigint`, () => {
-        it(`${BIGINT}`, () => expect(isNotUndefined(BIGINT)).toBe(TRUE));
-        it(`${BIGINT_EXPECTATION}`, () => expect(isNotUndefined(BIGINT_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`bigint`, () => {
+        testing.it(`${TESTING_BIGINT}`, () => expect(isNotUndefined(TESTING_BIGINT)).toBe(TESTING_TRUE));
+      })
 
       // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isNotUndefined(TRUE)).toBe(TRUE));
-        it(`${FALSE}`, () => expect(isNotUndefined(FALSE)).toBe(TRUE));
-        it(`${TRUE_EXPECTATION}`, () => expect(isNotUndefined(TRUE_INSTANCE)).toBe(TRUE));
-        it(`${TRUE_EXPECTATION}`, () => expect(isNotUndefined(TRUE_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`boolean`, () => {
+        testing
+        .it(`${TESTING_TRUE}`, () => expect(isNotUndefined(TESTING_TRUE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_FALSE}`, () => expect(isNotUndefined(TESTING_FALSE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isNotUndefined(TESTING_TRUE_INSTANCE)).toBe(TESTING_TRUE))
+        .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isNotUndefined(TESTING_TRUE_INSTANCE)).toBe(TESTING_TRUE));
+      })
 
       // null
-      it(`${NULL}`, () => expect(isNotUndefined(NULL)).toBe(TRUE));
+      .it(`${TESTING_NULL}`, () => expect(isNotUndefined(TESTING_NULL)).toBe(TESTING_TRUE))
 
       // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isNotUndefined(NUMBER)).toBe(TRUE));
-        it(`Number(${NUMBER})`, () => expect(isNotUndefined(NUMBER_INSTANCE)).toBe(TRUE));
-        it(`new Number(${NUMBER})`, () => expect(isNotUndefined(NUMBER_NEW_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`number`, () => {
+        testing
+        .it(`${TESTING_NUMBER}`, () => expect(isNotUndefined(TESTING_NUMBER)).toBe(TESTING_TRUE))
+        .it(`Number(${TESTING_NUMBER})`, () => expect(isNotUndefined(TESTING_NUMBER_CONSTRUCTOR)).toBe(TESTING_TRUE))
+        .it(`new Number(${TESTING_NUMBER})`, () => expect(isNotUndefined(TESTING_NUMBER_INSTANCE)).toBe(TESTING_TRUE));
+      })
       // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isNotUndefined(STRING)).toBe(TRUE));
-        it(`String(${STRING})`, () => expect(isNotUndefined(STRING_INSTANCE)).toBe(TRUE));
-        it(`new String(${STRING})`, () => expect(isNotUndefined(STRING_NEW_INSTANCE)).toBe(TRUE));
-      });
+      .describe(`string`, () => {
+        testing
+        .it(`${TESTING_STRING}`, () => expect(isNotUndefined(TESTING_STRING)).toBe(TESTING_TRUE))
+        .it(`String(${TESTING_STRING})`, () => expect(isNotUndefined(TESTING_STRING_CONSTRUCTOR)).toBe(TESTING_TRUE))
+        .it(`new String(${TESTING_STRING})`, () => expect(isNotUndefined(TESTING_STRING_INSTANCE)).toBe(TESTING_TRUE));
+      })
       // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isNotUndefined(SYMBOL_NUMBER)).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(isNotUndefined(SYMBOL_STRING)).toBe(TRUE));
-      });
+      .describe(`symbol`, () => {
+        testing
+        .it(`Symbol(${TESTING_NUMBER})`, () => expect(isNotUndefined(TESTING_SYMBOL_NUMBER)).toBe(TESTING_TRUE))
+        .it(`Symbol(${TESTING_STRING})`, () => expect(isNotUndefined(TESTING_SYMBOL_STRING)).toBe(TESTING_TRUE));
+      })
       // undefined
-      it(`${UNDEFINED}`, () => expect(isNotUndefined(UNDEFINED)).toBe(FALSE));
+      .it(`${TESTING_UNDEFINED}`, () => expect(isNotUndefined(TESTING_UNDEFINED)).toBe(TESTING_FALSE));
     });
   });
 });
diff --git a/src/is/not/test/is-not.spec.ts b/src/is/not/test/is-not.spec.ts
index 8c57dab8..617ecbc4 100644
--- a/src/is/not/test/is-not.spec.ts
+++ b/src/is/not/test/is-not.spec.ts
@@ -1,28 +1,32 @@
 import { isNot } from '../lib/is-not.object';
-
-describe('`isNot`', () => {
-   describe('DEFINED', () => {
-      it('isNot', () => expect(isNot).toBeDefined());
-      // it('isNot.array()', () => expect(isNot.boolean).toBeDefined());
-      it('isNot.boolean()', () => expect(isNot.boolean).toBeDefined());
-      // it('isNot.booleanObject()', () => expect(isNot.booleanObject).toBeDefined());
-      // it('isNot.booleanType()', () => expect(isNot.booleanType).toBeDefined());
-      it('isNot.defined()', () => expect(isNot.defined).toBeDefined());
-      it('isNot.function()', () => expect(isNot.function).toBeDefined());
-      // it('isNot.instance()', () => expect(isNot.instance).toBeDefined());
-      // it('isNot.key()', () => expect(isNot.key).toBeDefined());
-      it('isNot.null()', () => expect(isNot.null).toBeDefined());
-      it('isNot.number()', () => expect(isNot.number).toBeDefined());
-      // it('isNot.numberObject()', () => expect(isNot.numberObject).toBeDefined());
-      // it('isNot.numberType()', () => expect(isNot.numberType).toBeDefined());
-      // it('isNot.object()', () => expect(isNot.object).toBeDefined());
-      // it('isNot.objectKey()', () => expect(isNot.objectKey).toBeDefined());
-      // it('isNot.primitive()', () => expect(isNot.primitive).toBeDefined());
-      it('isNot.string()', () => expect(isNot.string).toBeDefined());
-      // it('isNot.stringObject()', () => expect(isNot.stringObject).toBeDefined());
-      // it('isNot.stringType()', () => expect(isNot.stringType).toBeDefined());
-      // it('isNot.symbol()', () => expect(isNot.symbol).toBeDefined());
-      // it('isNot.type()', () => expect(isNot.type).toBeDefined());
-      it('isNot.undefined()', () => expect(isNot.undefined).toBeDefined());
+// Testing.
+import {
+   // Main.
+   Testing,
+ } from '@angular-package/testing';
+ // Execute tests.
+import { tests } from '../../../execute-tests';
+ /**
+  * Initialize testing.
+  */
+const testing = new Testing(
+   tests.object.isNot.describe,
+   tests.object.isNot.it
+ );
+ /**
+  * Tests.
+  */
+testing.describe(`guard`, () => {
+   testing
+   .describe('DEFINED', () => {
+      testing
+      .it('isNot', () => expect(isNot).toBeDefined())
+      .it('isNot.boolean()', () => expect(isNot.boolean).toBeDefined())
+      .it('isNot.defined()', () => expect(isNot.defined).toBeDefined())
+      .it('isNot.function()', () => expect(isNot.function).toBeDefined())
+      .it('isNot.null()', () => expect(isNot.null).toBeDefined())
+      .it('isNot.number()', () => expect(isNot.number).toBeDefined())
+      .it('isNot.string()', () => expect(isNot.string).toBeDefined())
+      .it('isNot.undefined()', () => expect(isNot.undefined).toBeDefined());
    });
 });
diff --git a/src/is/not/type/is-not-boolean.type.ts b/src/is/not/type/is-not-boolean.type.ts
deleted file mode 100644
index d81872f9..00000000
--- a/src/is/not/type/is-not-boolean.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { AnyBoolean } from '../../../type/any-boolean.type';
-import { Never } from '../../../type/never.type';
-import { ResultCallback } from '../../../type/result-callback.type';
-export type IsNotBoolean = <Type>(value: Type, callback?: ResultCallback) => value is Never<AnyBoolean, Type>;
diff --git a/src/is/not/type/is-not-defined.type.ts b/src/is/not/type/is-not-defined.type.ts
deleted file mode 100644
index de1d8cf5..00000000
--- a/src/is/not/type/is-not-defined.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { ResultCallback } from '../../../type/result-callback.type';
-import { Undefined } from '../../../type/undefined.type';
-export type IsNotDefined = <Type>(value: Type, callback?: ResultCallback) => value is Undefined<Type>;
diff --git a/src/is/not/type/is-not-function.type.ts b/src/is/not/type/is-not-function.type.ts
deleted file mode 100644
index f5b04ef0..00000000
--- a/src/is/not/type/is-not-function.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { Func } from '../../../type/func.type';
-import { Never } from '../../../type/never.type';
-import { ResultCallback } from '../../../type/result-callback.type';
-export type IsNotFunction = <Type>(value: Type, callback?: ResultCallback) => value is Never<Func, Type>;
diff --git a/src/is/not/type/is-not-null.type.ts b/src/is/not/type/is-not-null.type.ts
deleted file mode 100644
index 0b45aeb3..00000000
--- a/src/is/not/type/is-not-null.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Never } from '../../../type/never.type';
-import { ResultCallback } from '../../../type/result-callback.type';
-export type IsNotNull = <Type>(value: Type, callback?: ResultCallback) => value is Never<null, Type>;
diff --git a/src/is/not/type/is-not-number.type.ts b/src/is/not/type/is-not-number.type.ts
deleted file mode 100644
index d9bd95b9..00000000
--- a/src/is/not/type/is-not-number.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { AnyNumber } from '../../../type/any-number.type';
-import { Never } from '../../../type/never.type';
-import { ResultCallback } from '../../../type/result-callback.type';
-export type IsNotNumber = <Type>(value: Type, callback?: ResultCallback) => value is Never<AnyNumber, Type>;
diff --git a/src/is/not/type/is-not-string.type.ts b/src/is/not/type/is-not-string.type.ts
deleted file mode 100644
index f08dc72d..00000000
--- a/src/is/not/type/is-not-string.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { AnyString } from '../../../type/any-string.type';
-import { Never } from '../../../type/never.type';
-import { ResultCallback } from '../../../type/result-callback.type';
-export type IsNotString = <Type>(value: Type, callback?: ResultCallback) => value is Never<AnyString, Type>;
diff --git a/src/is/not/type/is-not-undefined.type.ts b/src/is/not/type/is-not-undefined.type.ts
deleted file mode 100644
index f3777bbd..00000000
--- a/src/is/not/type/is-not-undefined.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Defined } from '../../../type/defined.type';
-import { ResultCallback } from '../../../type/result-callback.type';
-export type IsNotUndefined = <Type>(value: Type, callback?: ResultCallback) => value is Defined<Type>;
diff --git a/src/is/test/is-array.spec.ts b/src/is/test/is-array.spec.ts
index a56d087f..89d361ba 100644
--- a/src/is/test/is-array.spec.ts
+++ b/src/is/test/is-array.spec.ts
@@ -1,84 +1,110 @@
-import { BIGINT, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { Func } from '../../type/func.type';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Function.
 import { isArray } from '../lib/is-array.func';
-import { notDefined } from '../../testing/src/not-defined.const';
+// Testing.
 import {
-  ARRAY_BIGINT,
-  ARRAY_BOOLEAN,
-  ARRAY_CLASS,
-  ARRAY_FUNCTION,
-  ARRAY_NULL,
-  ARRAY_NUMBER,
-  ARRAY_OBJECT_ONE,
-  ARRAY_OBJECT_TWO,
-  ARRAY_STRING,
-  ARRAY_SYMBOL_NUMBER,
-  ARRAY_SYMBOL_STRING,
-  ARRAY_UNDEFINED
-} from '../../testing/src/array.const';
-// Interface.
-import { ObjectOne, ObjectTwo } from '../../testing/interface';
+  // Main.
+  Testing,
 
-describe(isArray.name, () => {
+  // Constant.
+  TESTING_ARRAY_BIGINT,
+  TESTING_ARRAY_BOOLEAN,
+  TESTING_ARRAY_CLASS,
+  TESTING_ARRAY_FUNCTION,
+  TESTING_ARRAY_NULL,
+  TESTING_ARRAY_NUMBER,
+  TESTING_ARRAY_OBJECT_ONE,
+  TESTING_ARRAY_STRING,
+  TESTING_ARRAY_SYMBOL_NUMBER,
+  TESTING_ARRAY_SYMBOL_STRING,
+  TESTING_ARRAY_UNDEFINED,
+  TESTING_BIGINT,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
-  // TRUE
-  it('is DEFINED', () => expect(isArray).toBeDefined());
-  it('Array<bigint>', () => expect(isArray<bigint>(ARRAY_BIGINT)).toBe(TRUE));
-  it('Array<boolean>', () => expect(isArray<boolean>(ARRAY_BOOLEAN)).toBe(TRUE));
-  it('Array<Class>', () => expect(isArray<Class>(ARRAY_CLASS)).toBe(TRUE));
-  it('Array<Func>', () => expect(isArray<Func>(ARRAY_FUNCTION)).toBe(TRUE));
-  it('Array<null>', () => expect(isArray<null>(ARRAY_NULL)).toBe(TRUE));
-  it('Array<number>', () => expect(isArray<number>(ARRAY_NUMBER)).toBe(TRUE));
-  it('Array<ObjectOne> Array<ObjectTwo>', () => {
-    expect(isArray<ObjectOne>(ARRAY_OBJECT_ONE)).toBe(TRUE);
-    expect(isArray<ObjectTwo>(ARRAY_OBJECT_TWO)).toBe(TRUE);
-  });
-  it('Array<string>', () => expect(isArray<string>(ARRAY_STRING)).toBe(TRUE));
-  it('Array<symbol>', () => {
-    expect(isArray<symbol>(ARRAY_SYMBOL_STRING)).toBe(TRUE);
-    expect(isArray<symbol>(ARRAY_SYMBOL_NUMBER)).toBe(TRUE);
-  });
-  it('Array<undefined>', () => expect(isArray<undefined>(ARRAY_UNDEFINED)).toBe(TRUE));
+  // Class.
+  TestingClass,
 
-  // FALSE
-  it(`'bigint'`, () => {
-    expect(isArray(BIGINT)).toBe(FALSE);
-    expect(isArray(BIGINT_INSTANCE)).toBe(FALSE);
-  });
-  it(`'boolean' | Boolean`, () => {
-    expect(isArray(FALSE)).toBe(FALSE);
-    expect(isArray(TRUE)).toBe(FALSE);
-    expect(isArray(FALSE_INSTANCE)).toBe(FALSE);
-    expect(isArray(TRUE_INSTANCE)).toBe(FALSE);
-  });
-  it(`'function' | Function`, () => expect(isArray(FUNCTION)).toBe(FALSE));
-  it(`'number' | Number`, () => {
-    expect(isArray(NUMBER)).toBe(FALSE);
-    expect(isArray(NUMBER_INSTANCE)).toBe(FALSE);
-    expect(isArray(NUMBER_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'object' | Object`, () => {
-    expect(isArray(OBJECT_ONE)).toBe(FALSE);
-    expect(isArray(OBJECT_TWO)).toBe(FALSE);
-  });
-  it(`'string' | String`, () => {
-    expect(isArray(STRING)).toBe(FALSE);
-    expect(isArray(STRING_INSTANCE)).toBe(FALSE);
-  });
-  it(`'symbol'`, () => {
-    expect(isArray(SYMBOL_NUMBER)).toBe(FALSE);
-    expect(isArray(SYMBOL_STRING)).toBe(FALSE);
-  });
-  it(`'undefined'`, () => {
-    expect(isArray(notDefined)).toBe(FALSE);
-    expect(isArray(UNDEFINED)).toBe(FALSE);
-  });
+  // Interface.
+  TestingObject,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.array.describe,
+  tests.is.array.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isArray.name, () => {
+  let TESTING_NOT_DEFINED: unknown;
+  // TESTING_TRUE
+  testing
+    .it('is DEFINED', () => expect(isArray).toBeDefined())
+    .it(`callback and custom payload`, () => {
+      isArray<bigint, { database: string }>(TESTING_ARRAY_BIGINT, (result, value, payload) => (
+        expect(result).toBeTrue(),
+        expect(value).toEqual(TESTING_ARRAY_BIGINT),
+        expect(payload?.database).toEqual('Person'),
+        result
+      ), { database: 'Person' });
+    })
+    .it('Array<bigint>', () => expect(isArray<bigint>(TESTING_ARRAY_BIGINT)).toBeTrue())
+    .it('Array<boolean>', () => expect(isArray<boolean>(TESTING_ARRAY_BOOLEAN)).toBeTrue())
+    .it('Array<TestingClass>', () => expect(isArray<TestingClass>(TESTING_ARRAY_CLASS)).toBeTrue())
+    .it('Array<Func>', () => expect(isArray<Function>(TESTING_ARRAY_FUNCTION)).toBeTrue())
+    .it('Array<null>', () => expect(isArray<null>(TESTING_ARRAY_NULL)).toBeTrue())
+    .it('Array<number>', () => expect(isArray<number>(TESTING_ARRAY_NUMBER)).toBeTrue())
+    .it('Array<ObjectOne> Array<ObjectTwo>', () => (expect(isArray<TestingObject>(TESTING_ARRAY_OBJECT_ONE)).toBeTrue()))
+    .it('Array<string>', () => expect(isArray<string>(TESTING_ARRAY_STRING)).toBeTrue())
+    .it('Array<symbol>', () => (
+      expect(isArray<symbol>(TESTING_ARRAY_SYMBOL_STRING)).toBeTrue(),
+      expect(isArray<symbol>(TESTING_ARRAY_SYMBOL_NUMBER)).toBeTrue()
+    ))
+    .it('Array<undefined>', () => expect(isArray<undefined>(TESTING_ARRAY_UNDEFINED)).toBeTrue())
+
+    // TESTING_FALSE
+    .it(`'bigint'`, () => expect(isArray(TESTING_BIGINT)).toBeFalse())
+    .it(`'boolean' | Boolean`, () => {
+      expect(isArray(TESTING_FALSE)).toBeFalse();
+      expect(isArray(TESTING_TRUE)).toBeFalse();
+      expect(isArray(TESTING_FALSE_INSTANCE)).toBeFalse();
+      expect(isArray(TESTING_TRUE_INSTANCE)).toBeFalse();
+    })
+    .it(`'function' | Function`, () => expect(isArray(TESTING_FUNCTION)).toBeFalse())
+    .it(`'number' | Number`, () => {
+      expect(isArray(TESTING_NUMBER)).toBeFalse();
+      expect(isArray(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse();
+      expect(isArray(TESTING_NUMBER_INSTANCE)).toBeFalse();
+    })
+    .it(`'object' | Object`, () => {
+      expect(isArray(TESTING_OBJECT)).toBeFalse();
+    })
+    .it(`'string' | String`, () => {
+      expect(isArray(TESTING_STRING)).toBeFalse();
+      expect(isArray(TESTING_STRING_INSTANCE)).toBeFalse();
+    })
+    .it(`'symbol'`, () => {
+      expect(isArray(TESTING_SYMBOL_NUMBER)).toBeFalse();
+      expect(isArray(TESTING_SYMBOL_STRING)).toBeFalse();
+    })
+    .it(`'undefined'`, () => (
+      expect(isArray(TESTING_NOT_DEFINED)).toBeFalse(),
+      expect(isArray(TESTING_UNDEFINED)).toBeFalse()
+    ));
 });
diff --git a/src/is/test/is-big-int.spec.ts b/src/is/test/is-big-int.spec.ts
index 8c65a678..eac70f9c 100644
--- a/src/is/test/is-big-int.spec.ts
+++ b/src/is/test/is-big-int.spec.ts
@@ -1,73 +1,90 @@
-import { BIGINT, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { CLASS, Class } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Function.
 import { isBigInt } from '../lib/is-big-int.func';
-import { notDefined } from '../../testing/src/not-defined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
 /**
- * Checks
- * ✓ typeof === 'bigint'
+ * Initialize testing.
  */
-describe(isBigInt.name, () => {
-  // TRUE
-  it('is DEFINED', () => {
-    expect(isBigInt).toBeDefined();
-  });
-  it(`bigint`, () => {
-    expect(isBigInt(BIGINT)).toBe(TRUE);
-    expect(isBigInt(BIGINT_INSTANCE)).toBe(TRUE);
-    isBigInt(BIGINT_INSTANCE, (result: boolean) => {
-      expect(result).toBe(TRUE);
-      return result;
-    });
-  });
-
-  // FALSE
-  it(`boolean | Boolean`, () => {
-    expect(isBigInt(FALSE)).toBe(FALSE);
-    expect(isBigInt(TRUE)).toBe(FALSE);
-    expect(isBigInt(FALSE_INSTANCE)).toBe(FALSE);
-    expect(isBigInt(TRUE_INSTANCE)).toBe(FALSE);
-    isBigInt(FALSE, (result: boolean) => {
-      expect(result).toBe(FALSE);
-      return result;
-    });
-  });
-  it(`Class | CLASS`, () => {
-    expect(isBigInt(Class)).toBe(FALSE);
-    expect(isBigInt(CLASS)).toBe(FALSE);
-  });
-  it(`function | Function`, () => expect(isBigInt(FUNCTION)).toBe(FALSE));
-  it(`null | NULL`, () => {
-    expect(isBigInt(null)).toBe(FALSE);
-    expect(isBigInt(NULL)).toBe(FALSE);
-  });
-  it(`'number' | Number`, () => {
-    expect(isBigInt(NUMBER)).toBe(FALSE);
-    expect(isBigInt(NUMBER_INSTANCE)).toBe(FALSE);
-    expect(isBigInt(NUMBER_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'object' | Object`, () => {
-    expect(isBigInt(OBJECT_ONE)).toBe(FALSE);
-    expect(isBigInt(OBJECT_TWO)).toBe(FALSE);
-  });
-  it(`'string' | String`, () => {
-    expect(isBigInt(STRING)).toBe(FALSE);
-    expect(isBigInt(STRING_INSTANCE)).toBe(FALSE);
-    expect(isBigInt(STRING_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'symbol'`, () => {
-    expect(isBigInt(SYMBOL_NUMBER)).toBe(FALSE);
-    expect(isBigInt(SYMBOL_STRING)).toBe(FALSE);
-  });
-  it(`'undefined'`, () => {
-    expect(isBigInt(notDefined)).toBe(FALSE);
-    expect(isBigInt(UNDEFINED)).toBe(FALSE);
-  });
-});
+const testing = new Testing(
+  tests.is.bigint.describe,
+  tests.is.bigint.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isBigInt.name, () =>
+  testing
+    .toBeInstanceOfFunction(isBigInt)
+    .it(`defined`, () => expect(isBigInt).toBeDefined())
+    .it(`bigint`, () => (
+      expect(isBigInt(TESTING_BIGINT)).toBeTrue(),
+      isBigInt(TESTING_BIGINT, (result: boolean) => {
+        expect(result).toBeTrue();
+        return result;
+      }),
+      expect(isBigInt(1n)).toBeTrue()
+    ))
+    .it(`boolean | Boolean`, () => (
+      expect(isBigInt(TESTING_FALSE)).toBeFalse(),
+      expect(isBigInt(TESTING_TRUE)).toBeFalse(),
+      expect(isBigInt(TESTING_FALSE_INSTANCE)).toBeFalse(),
+      expect(isBigInt(TESTING_TRUE_INSTANCE)).toBeFalse(),
+      isBigInt(TESTING_FALSE, (result: boolean) => {
+        expect(result).toBeFalse();
+        return result;
+      })
+    ))
+    .it(`TestingClass | TESTING_CLASS`, () => (
+      expect(isBigInt(TestingClass)).toBeFalse(),
+      expect(isBigInt(TESTING_CLASS)).toBeFalse()
+    ))
+    .it(`function | Function`, () => expect(isBigInt(TESTING_FUNCTION)).toBeFalse())
+    .it(`null | TESTING_NULL`, () => (
+      expect(isBigInt(null)).toBeFalse(),
+      expect(isBigInt(TESTING_NULL)).toBeFalse()
+    ))
+    .it(`'number' | Number`, () => (
+      expect(isBigInt(TESTING_NUMBER)).toBeFalse(),
+      expect(isBigInt(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse(),
+      expect(isBigInt(TESTING_NUMBER_INSTANCE)).toBeFalse()
+    ))
+    .it(`'object' | Object`, () => expect(isBigInt(TESTING_OBJECT)).toBeFalse())
+    .it(`'string' | String`, () => (
+      expect(isBigInt(TESTING_STRING)).toBeFalse(),
+      expect(isBigInt(TESTING_STRING_CONSTRUCTOR)).toBeFalse(),
+      expect(isBigInt(TESTING_STRING_INSTANCE)).toBeFalse()
+    ))
+    .it(`'symbol'`, () => (
+      expect(isBigInt(TESTING_SYMBOL_NUMBER)).toBeFalse(),
+      expect(isBigInt(TESTING_SYMBOL_STRING)).toBeFalse()
+    ))
+    .it(`'undefined'`, () => expect(isBigInt(TESTING_UNDEFINED)).toBeFalse())
+);
diff --git a/src/is/test/is-boolean-object.spec.ts b/src/is/test/is-boolean-object.spec.ts
index 455255bf..c2dead4c 100644
--- a/src/is/test/is-boolean-object.spec.ts
+++ b/src/is/test/is-boolean-object.spec.ts
@@ -1,71 +1,88 @@
 // Function.
 import { isBooleanObject } from '../lib/is-boolean-object.func';
-// Constant.
-import { BIGINT, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
-import { notDefined } from '../../testing/src/not-defined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.booleanObject.describe,
+  tests.is.booleanObject.it
+);
 /**
- * Checks
- * ✓ typeof === 'object'
- * ✓ instanceof Object
- * ✓ instanceof Boolean
+ * Tests.
  */
-describe(isBooleanObject.name, () => {
-  // TRUE
-  it('is DEFINED', () => expect(isBooleanObject).toBeDefined());
-  it(`Boolean`, () => {
-    expect(isBooleanObject(FALSE_INSTANCE)).toBe(TRUE);
-    expect(isBooleanObject(TRUE_INSTANCE)).toBe(TRUE);
-  });
+testing.describe(isBooleanObject.name, () => {
+  testing
+    // TRUE
+    .it('is DEFINED', () => expect(isBooleanObject).toBeDefined())
+    .it(`Boolean`, () => {
+      expect(isBooleanObject(TESTING_FALSE_INSTANCE)).toBeTrue();
+      expect(isBooleanObject(TESTING_TRUE_INSTANCE)).toBeTrue();
+    })
 
-  // FALSE
-  it(`boolean`, () => {
-    expect(isBooleanObject(FALSE)).toBe(FALSE);
-    expect(isBooleanObject(TRUE)).toBe(FALSE);
-    expect(isBooleanObject(Boolean(false))).toBe(FALSE);
-    expect(isBooleanObject(Boolean(true))).toBe(FALSE);
-  });
-  it(`'bigint'`, () => {
-    expect(isBooleanObject(BIGINT)).toBe(FALSE);
-    expect(isBooleanObject(BIGINT_INSTANCE)).toBe(FALSE);
-  });
-  it(`Class | CLASS`, () => {
-    expect(isBooleanObject(Class)).toBe(FALSE);
-    expect(isBooleanObject(CLASS)).toBe(FALSE);
-  });
-  it(`'function' | Function`, () => expect(isBooleanObject(FUNCTION)).toBe(FALSE));
-  it(`null | NULL`, () => {
-    expect(isBooleanObject(null)).toBe(FALSE);
-    expect(isBooleanObject(NULL)).toBe(FALSE);
-  });
-  it(`'number' | Number`, () => {
-    expect(isBooleanObject(NUMBER)).toBe(FALSE);
-    expect(isBooleanObject(NUMBER_INSTANCE)).toBe(FALSE);
-    expect(isBooleanObject(NUMBER_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'object' | Object`, () => {
-    expect(isBooleanObject(OBJECT_ONE)).toBe(FALSE);
-    expect(isBooleanObject(OBJECT_TWO)).toBe(FALSE);
-  });
-  it(`'string' | String`, () => {
-    expect(isBooleanObject(STRING)).toBe(FALSE);
-    expect(isBooleanObject(STRING_INSTANCE)).toBe(FALSE);
-    expect(isBooleanObject(STRING_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'symbol'`, () => {
-    expect(isBooleanObject(SYMBOL_NUMBER)).toBe(FALSE);
-    expect(isBooleanObject(SYMBOL_STRING)).toBe(FALSE);
-  });
-  it(`'undefined'`, () => {
-    expect(isBooleanObject(notDefined)).toBe(FALSE);
-    expect(isBooleanObject(UNDEFINED)).toBe(FALSE);
-  });
+    // FALSE
+    .it(`boolean`, () => {
+      expect(isBooleanObject(TESTING_FALSE)).toBeFalse();
+      expect(isBooleanObject(TESTING_TRUE)).toBeFalse();
+      expect(isBooleanObject(Boolean(false))).toBeFalse();
+      expect(isBooleanObject(Boolean(true))).toBeFalse();
+    })
+    .it(`'bigint'`, () => {
+      expect(isBooleanObject(TESTING_BIGINT)).toBeFalse();
+      expect(isBooleanObject(TESTING_BIGINT)).toBeFalse();
+    })
+    .it(`TestingClass | TESTING_CLASS`, () => {
+      expect(isBooleanObject(TestingClass)).toBeFalse();
+      expect(isBooleanObject(TESTING_CLASS)).toBeFalse();
+    })
+    .it(`'function' | Function`, () => expect(isBooleanObject(TESTING_FUNCTION)).toBeFalse())
+    .it(`null | TESTING_NULL`, () => {
+      expect(isBooleanObject(null)).toBeFalse();
+      expect(isBooleanObject(TESTING_NULL)).toBeFalse();
+    })
+    .it(`'number' | Number`, () => {
+      expect(isBooleanObject(TESTING_NUMBER)).toBeFalse();
+      expect(isBooleanObject(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse();
+      expect(isBooleanObject(TESTING_NUMBER_INSTANCE)).toBeFalse();
+    })
+    .it(`'object' | Object`, () => expect(isBooleanObject(TESTING_OBJECT)).toBeFalse())
+    .it(`'string' | String`, () => {
+      expect(isBooleanObject(TESTING_STRING)).toBeFalse();
+      expect(isBooleanObject(TESTING_STRING_CONSTRUCTOR)).toBeFalse();
+      expect(isBooleanObject(TESTING_STRING_INSTANCE)).toBeFalse();
+    })
+    .it(`'symbol'`, () => {
+      expect(isBooleanObject(TESTING_SYMBOL_NUMBER)).toBeFalse();
+      expect(isBooleanObject(TESTING_SYMBOL_STRING)).toBeFalse();
+    })
+    .it(`'undefined'`, () => expect(isBooleanObject(TESTING_UNDEFINED)).toBeFalse());
 });
diff --git a/src/is/test/is-boolean-type.spec.ts b/src/is/test/is-boolean-type.spec.ts
index 77350327..fb1d3cf3 100644
--- a/src/is/test/is-boolean-type.spec.ts
+++ b/src/is/test/is-boolean-type.spec.ts
@@ -1,71 +1,88 @@
 // Function.
 import { isBooleanType } from '../lib/is-boolean-type.func';
-// Constant.
-import { BIGINT, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
-import { notDefined } from '../../testing/src/not-defined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.booleanType.describe,
+  tests.is.booleanType.it
+);
 /**
- * Checks
- * ✓ typeof === 'boolean'
- * ✓ value === true
- * ✓ value === false
+ * Tests.
  */
-describe(isBooleanType.name, () => {
+testing.describe(isBooleanType.name, () => {
   // TRUE
-  it('is DEFINED', () => expect(isBooleanType).toBeDefined());
-  it(`boolean`, () => {
-    expect(isBooleanType(FALSE)).toBe(TRUE);
-    expect(isBooleanType(TRUE)).toBe(TRUE);
-    expect(isBooleanType(Boolean(false))).toBe(TRUE);
-    expect(isBooleanType(Boolean(true))).toBe(TRUE);
-  });
+  testing
+    .it('is DEFINED', () => expect(isBooleanType).toBeDefined())
+    .it(`boolean`, () => {
+      expect(isBooleanType(TESTING_FALSE)).toBeTrue();
+      expect(isBooleanType(TESTING_TRUE)).toBeTrue();
+      expect(isBooleanType(Boolean(false))).toBeTrue();
+      expect(isBooleanType(Boolean(true))).toBeTrue();
+    })
 
-  // FALSE
-  it(`Boolean`, () => {
-    expect(isBooleanType(FALSE_INSTANCE)).toBe(FALSE);
-    expect(isBooleanType(TRUE_INSTANCE)).toBe(FALSE);
-  });
-  it(`'bigint'`, () => {
-    expect(isBooleanType(BIGINT)).toBe(FALSE);
-    expect(isBooleanType(BIGINT_INSTANCE)).toBe(FALSE);
-  });
-  it(`Class | CLASS`, () => {
-    expect(isBooleanType(Class)).toBe(FALSE);
-    expect(isBooleanType(CLASS)).toBe(FALSE);
-  });
-  it(`'function' | Function`, () => expect(isBooleanType(FUNCTION)).toBe(FALSE));
-  it(`null | NULL`, () => {
-    expect(isBooleanType(null)).toBe(FALSE);
-    expect(isBooleanType(NULL)).toBe(FALSE);
-  });
-  it(`'number' | Number`, () => {
-    expect(isBooleanType(NUMBER)).toBe(FALSE);
-    expect(isBooleanType(NUMBER_INSTANCE)).toBe(FALSE);
-    expect(isBooleanType(NUMBER_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'object' | Object`, () => {
-    expect(isBooleanType(OBJECT_ONE)).toBe(FALSE);
-    expect(isBooleanType(OBJECT_TWO)).toBe(FALSE);
-  });
-  it(`'string' | String`, () => {
-    expect(isBooleanType(STRING)).toBe(FALSE);
-    expect(isBooleanType(STRING_INSTANCE)).toBe(FALSE);
-    expect(isBooleanType(STRING_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'symbol'`, () => {
-    expect(isBooleanType(SYMBOL_NUMBER)).toBe(FALSE);
-    expect(isBooleanType(SYMBOL_STRING)).toBe(FALSE);
-  });
-  it(`'undefined'`, () => {
-    expect(isBooleanType(notDefined)).toBe(FALSE);
-    expect(isBooleanType(UNDEFINED)).toBe(FALSE);
-  });
+    // FALSE
+    .it(`Boolean`, () => {
+      expect(isBooleanType(TESTING_FALSE_INSTANCE)).toBeFalse();
+      expect(isBooleanType(TESTING_TRUE_INSTANCE)).toBeFalse();
+    })
+    .it(`'bigint'`, () => {
+      expect(isBooleanType(TESTING_BIGINT)).toBeFalse();
+      expect(isBooleanType(TESTING_BIGINT)).toBeFalse();
+    })
+    .it(`TestingClass | TESTING_CLASS`, () => {
+      expect(isBooleanType(TestingClass)).toBeFalse();
+      expect(isBooleanType(TESTING_CLASS)).toBeFalse();
+    })
+    .it(`'function' | Function`, () => expect(isBooleanType(TESTING_FUNCTION)).toBeFalse())
+    .it(`null | TESTING_NULL`, () => {
+      expect(isBooleanType(null)).toBeFalse();
+      expect(isBooleanType(TESTING_NULL)).toBeFalse();
+    })
+    .it(`'number' | Number`, () => {
+      expect(isBooleanType(TESTING_NUMBER)).toBeFalse();
+      expect(isBooleanType(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse();
+      expect(isBooleanType(TESTING_NUMBER_INSTANCE)).toBeFalse();
+    })
+    .it(`'object' | Object`, () => expect(isBooleanType(TESTING_OBJECT)).toBeFalse())
+    .it(`'string' | String`, () => {
+      expect(isBooleanType(TESTING_STRING)).toBeFalse();
+      expect(isBooleanType(TESTING_STRING_CONSTRUCTOR)).toBeFalse();
+      expect(isBooleanType(TESTING_STRING_INSTANCE)).toBeFalse();
+    })
+    .it(`'symbol'`, () => {
+      expect(isBooleanType(TESTING_SYMBOL_NUMBER)).toBeFalse();
+      expect(isBooleanType(TESTING_SYMBOL_STRING)).toBeFalse();
+    })
+    .it(`'undefined'`, () => expect(isBooleanType(TESTING_UNDEFINED)).toBeFalse());
 });
diff --git a/src/is/test/is-boolean.spec.ts b/src/is/test/is-boolean.spec.ts
index 80c6db59..4657f3bd 100644
--- a/src/is/test/is-boolean.spec.ts
+++ b/src/is/test/is-boolean.spec.ts
@@ -1,76 +1,94 @@
 // Function.
 import { isBoolean } from '../lib/is-boolean.func';
-// Constant.
-import { BIGINT, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
-import { notDefined } from '../../testing/src/not-defined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.boolean.describe,
+  tests.is.boolean.it
+);
 /**
- * Checks
- * ✓ typeof === 'boolean'
- * ✓ instanceof Boolean
+ * Tests.
  */
-describe(isBoolean.name, () => {
-  // TRUE
-  it('is DEFINED', () => expect(isBoolean).toBeDefined());
-  it(`'boolean' | Boolean`, () => {
-    expect(isBoolean(FALSE)).toBe(TRUE);
-    expect(isBoolean(TRUE)).toBe(TRUE);
-    expect(isBoolean(FALSE_INSTANCE)).toBe(TRUE);
-    expect(isBoolean(TRUE_INSTANCE)).toBe(TRUE);
-    expect(isBoolean(Boolean(false))).toBe(TRUE);
-    expect(isBoolean(Boolean(true))).toBe(TRUE);
-    isBoolean(FALSE, (result: boolean) => {
-      expect(result).toBe(TRUE);
-      return result;
-    });
-  });
+testing.describe(isBoolean.name, () =>
+  testing
+    // TRUE
+    .it('is DEFINED', () => expect(isBoolean).toBeDefined())
+    .it(`'boolean' | Boolean`, () => {
+      expect(isBoolean(TESTING_FALSE)).toBeTrue();
+      expect(isBoolean(TESTING_TRUE)).toBeTrue();
+      expect(isBoolean(TESTING_FALSE_INSTANCE)).toBeTrue();
+      expect(isBoolean(TESTING_TRUE_INSTANCE)).toBeTrue();
+      expect(isBoolean(Boolean(false))).toBeTrue();
+      expect(isBoolean(Boolean(true))).toBeTrue();
+      isBoolean(TESTING_FALSE, (result: boolean) => {
+        expect(result).toBeTrue();
+        return result;
+      });
+    })
 
-  // FALSE
-  it(`'bigint'`, () => {
-    expect(isBoolean(BIGINT)).toBe(FALSE);
-    expect(isBoolean(BIGINT_INSTANCE)).toBe(FALSE);
-    isBoolean(BIGINT, (result: boolean) => {
-      expect(result).toBe(FALSE);
-      return result;
-    });
-  });
-  it(`Class | CLASS`, () => {
-    expect(isBoolean(Class)).toBe(FALSE);
-    expect(isBoolean(CLASS)).toBe(FALSE);
-  });
-  it(`'function' | Function`, () => expect(isBoolean(FUNCTION)).toBe(FALSE));
-  it(`null | NULL`, () => {
-    expect(isBoolean(null)).toBe(FALSE);
-    expect(isBoolean(NULL)).toBe(FALSE);
-  });
-  it(`'number' | Number`, () => {
-    expect(isBoolean(NUMBER)).toBe(FALSE);
-    expect(isBoolean(NUMBER_INSTANCE)).toBe(FALSE);
-    expect(isBoolean(NUMBER_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'object' | Object`, () => {
-    expect(isBoolean(OBJECT_ONE)).toBe(FALSE);
-    expect(isBoolean(OBJECT_TWO)).toBe(FALSE);
-  });
-  it(`'string' | String`, () => {
-    expect(isBoolean(STRING)).toBe(FALSE);
-    expect(isBoolean(STRING_INSTANCE)).toBe(FALSE);
-    expect(isBoolean(STRING_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'symbol'`, () => {
-    expect(isBoolean(SYMBOL_NUMBER)).toBe(FALSE);
-    expect(isBoolean(SYMBOL_STRING)).toBe(FALSE);
-  });
-  it(`'undefined'`, () => {
-    expect(isBoolean(notDefined)).toBe(FALSE);
-    expect(isBoolean(UNDEFINED)).toBe(FALSE);
-  });
-});
+    // FALSE
+    .it(`'bigint'`, () => {
+      expect(isBoolean(TESTING_BIGINT)).toBeFalse();
+      expect(isBoolean(TESTING_BIGINT)).toBeFalse();
+      isBoolean(TESTING_BIGINT, (result: boolean) => {
+        expect(result).toBeFalse();
+        return result;
+      });
+    })
+    .it(`TestingClass | TESTING_CLASS`, () => {
+      expect(isBoolean(TestingClass)).toBeFalse();
+      expect(isBoolean(TESTING_CLASS)).toBeFalse();
+    })
+    .it(`'function' | Function`, () => expect(isBoolean(TESTING_FUNCTION)).toBeFalse())
+    .it(`null | TESTING_NULL`, () => {
+      expect(isBoolean(null)).toBeFalse();
+      expect(isBoolean(TESTING_NULL)).toBeFalse();
+    })
+    .it(`'number' | Number`, () => {
+      expect(isBoolean(TESTING_NUMBER)).toBeFalse();
+      expect(isBoolean(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse();
+      expect(isBoolean(TESTING_NUMBER_INSTANCE)).toBeFalse();
+    })
+    .it(`'object' | Object`, () => expect(isBoolean(TESTING_OBJECT)).toBeFalse())
+    .it(`'string' | String`, () => {
+      expect(isBoolean(TESTING_STRING)).toBeFalse();
+      expect(isBoolean(TESTING_STRING_CONSTRUCTOR)).toBeFalse();
+      expect(isBoolean(TESTING_STRING_INSTANCE)).toBeFalse();
+    })
+    .it(`'symbol'`, () => {
+      expect(isBoolean(TESTING_SYMBOL_NUMBER)).toBeFalse();
+      expect(isBoolean(TESTING_SYMBOL_STRING)).toBeFalse();
+    })
+    .it(`'undefined'`, () => expect(isBoolean(TESTING_UNDEFINED)).toBeFalse())
+);
diff --git a/src/is/test/is-class.spec.ts b/src/is/test/is-class.spec.ts
index 5fb21251..1f7944f4 100644
--- a/src/is/test/is-class.spec.ts
+++ b/src/is/test/is-class.spec.ts
@@ -1,93 +1,123 @@
 // Function.
 import { isClass } from '../lib/is-class.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.class.describe,
+  tests.is.class.it
+);
 /**
- * Checks
- * ✓ typeOf() === 'function' & typeof === 'function' && instanceof Object === true && instanceof Function === true
+ * Tests.
  */
-describe(isClass.name, () => {
+testing.describe(isClass.name, () => {
   // Defined.
-  it('is DEFINED', () => expect(isClass).toBeDefined());
+  testing.it('is DEFINED', () => expect(isClass).toBeDefined())
 
   // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isClass(Class, (result: boolean, value: any) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(Class);
+  .describe(`checks`, () => {
+    testing.it('callback', () => {
+      isClass(TestingClass, (result, value, payload) => {
+        expect(result).toBeTrue();
+        if (payload) {
+          expect(value).toEqual(TestingClass);
+        }
         return result;
       });
-    });
+    })
     // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isClass(FUNCTION, 'function')).toBe(FALSE));
-      // it(`${Class}`, () => expect(isClass(Class, 'function')).toBe(FALSE));
-    });
+    .describe(`array`, () => { })
     // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isClass(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isClass(Class)).toBe(TRUE));
-    });
+    .describe(`function`, () => {
+      testing
+        .it(`TESTING_FUNCTION`, () => expect(isClass(TESTING_FUNCTION)).toBeFalse())
+        .it(`TestingClass`, () => expect(isClass(TestingClass)).toBeTrue());
+    })
     // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isClass(CLASS)).toBe(FALSE));
-      it(`OBJECT_ONE`, () => expect(isClass(OBJECT_ONE)).toBe(FALSE));
-      it(`OBJECT_TWO`, () => expect(isClass(OBJECT_TWO)).toBe(FALSE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isClass(OBJECT_ONE_NEW)).toBe(FALSE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isClass(OBJECT_TWO_NEW)).toBe(FALSE));
-    });
+    .describe('object', () => {
+      testing
+        .it(`TESTING_CLASS`, () => expect(isClass(TESTING_CLASS)).toBeFalse())
+        .it(`TESTING_OBJECT`, () => expect(isClass(TESTING_OBJECT)).toBeFalse())
+        .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isClass(TESTING_OBJECT)).toBeFalse());
+    })
     // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isClass(BIGINT)).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isClass(TRUE)).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isClass(FALSE)).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isClass(NULL)).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isClass(NUMBER)).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isClass(NUMBER_INSTANCE)).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isClass(STRING)).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isClass(STRING_INSTANCE)).toBe(FALSE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isClass(SYMBOL_NUMBER)).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isClass(SYMBOL_STRING)).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isClass(UNDEFINED)).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isClass(BIGINT_INSTANCE)).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isClass(TRUE_INSTANCE)).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isClass(FALSE_INSTANCE)).toBe(FALSE));
+    .describe(`primitive`, () => {
+      testing
+        // bigint
+        .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isClass(TESTING_BIGINT)).toBeFalse()))
+        // boolean
+        .describe(`boolean`, () => {
+          testing
+            .it(`${TESTING_TRUE}`, () => expect(isClass(TESTING_TRUE)).toBeFalse())
+            .it(`${TESTING_FALSE}`, () => expect(isClass(TESTING_FALSE)).toBeFalse());
+        })
+        // null
+        .it(`${TESTING_NULL}`, () => expect(isClass(TESTING_NULL)).toBeFalse())
+        // number
+        .describe(`number`, () => {
+          testing
+            .it(`${TESTING_NUMBER}`, () => expect(isClass(TESTING_NUMBER)).toBeFalse())
+            .it(`Number(${TESTING_NUMBER})`, () => expect(isClass(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+        })
+        // string
+        .describe(`string`, () => {
+          testing
+            .it(`${TESTING_STRING}`, () => expect(isClass(TESTING_STRING)).toBeFalse())
+            .it(`String(${TESTING_STRING})`, () => expect(isClass(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+        })
+        // symbol
+        .describe(`symbol`, () => {
+          testing
+            .it(`Symbol(${TESTING_NUMBER})`, () => expect(isClass(TESTING_SYMBOL_NUMBER)).toBeFalse())
+            .it(`Symbol(${TESTING_STRING})`, () => expect(isClass(TESTING_SYMBOL_STRING)).toBeFalse());
+        })
+        // undefined
+        .it(`${TESTING_UNDEFINED}`, () => expect(isClass(TESTING_UNDEFINED)).toBeFalse())
+        // ... object.
+        .describe(`object`, () => {
+          testing
+            // BigInt
+            .describe(`BigInt`, () => it(`${TESTING_BIGINT}`, () => expect(isClass(TESTING_BIGINT)).toBeFalse()))
+            // Boolean
+            .describe(`Boolean`, () => {
+              it(`${TESTING_TRUE_INSTANCE}`, () => expect(isClass(TESTING_TRUE_INSTANCE)).toBeFalse());
+              it(`${TESTING_FALSE_INSTANCE}`, () => expect(isClass(TESTING_FALSE_INSTANCE)).toBeFalse());
+            })
+            // Number
+            .describe(`Number`, () => it(`new Number(${TESTING_NUMBER})`, () => expect(isClass(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+            // String
+            .describe(`String`, () => it(`new String(${TESTING_STRING})`, () => expect(isClass(TESTING_STRING_INSTANCE)).toBeFalse()));
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isClass(NUMBER_NEW_INSTANCE)).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isClass(STRING_NEW_INSTANCE)).toBe(FALSE)));
-      });
     });
   });
 });
diff --git a/src/is/test/is-date.spec.ts b/src/is/test/is-date.spec.ts
new file mode 100644
index 00000000..8b36b943
--- /dev/null
+++ b/src/is/test/is-date.spec.ts
@@ -0,0 +1,130 @@
+// Function.
+import { isDate } from '../lib/is-date.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_DATE,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.date.describe,
+  tests.is.date.it)
+;
+/**
+ * Tests.
+ */
+testing.describe(isDate.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isDate).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing.it('callback', () => {
+        isDate(TESTING_DATE, (result: boolean) => {
+          expect(result).toBeTrue();
+          return result;
+        });
+      })
+      // ... arrays.
+      .describe(`array`, () => { })
+      // ... Date.
+      .describe(`date`, () => {
+        testing
+          .it(`TESTING_DATE`, () => expect(isDate(TESTING_DATE)).toBeTrue())
+      })
+      // ... function.
+      .describe(`function`, () => {
+        testing
+          .it(`TESTING_FUNCTION`, () => expect(isDate(TESTING_FUNCTION)).toBeFalse())
+          .it(`TestingClass`, () => expect(isDate(TestingClass)).toBeFalse());
+      })
+      // ... objects.
+      .describe('object', () => {
+        testing
+          .it(`TESTING_CLASS`, () => expect(isDate(TESTING_CLASS)).toBeFalse())
+          .it(`TESTING_OBJECT`, () => expect(isDate(TESTING_OBJECT)).toBeFalse())
+          .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isDate(TESTING_OBJECT)).toBeFalse());
+      })
+      // ... primitives.
+      .describe(`primitive`, () => {
+        testing
+          // bigint
+          .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isDate(TESTING_BIGINT)).toBeFalse()))
+          // boolean
+          .describe(`boolean`, () => {
+            testing
+              .it(`${TESTING_TRUE}`, () => expect(isDate(TESTING_TRUE)).toBeFalse())
+              .it(`${TESTING_FALSE}`, () => expect(isDate(TESTING_FALSE)).toBeFalse());
+          })
+          // null
+          .it(`${TESTING_NULL}`, () => expect(isDate(TESTING_NULL)).toBeFalse())
+          // number
+          .describe(`number`, () => {
+            testing
+              .it(`${TESTING_NUMBER}`, () => expect(isDate(TESTING_NUMBER)).toBeFalse())
+              .it(`Number(${TESTING_NUMBER})`, () => expect(isDate(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+          })
+          // string
+          .describe(`string`, () => {
+            testing
+              .it(`${TESTING_STRING}`, () => expect(isDate(TESTING_STRING)).toBeFalse())
+              .it(`String(${TESTING_STRING})`, () => expect(isDate(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+          })
+          // symbol
+          .describe(`symbol`, () => {
+            testing
+              .it(`Symbol(${TESTING_NUMBER})`, () => expect(isDate(TESTING_SYMBOL_NUMBER)).toBeFalse())
+              .it(`Symbol(${TESTING_STRING})`, () => expect(isDate(TESTING_SYMBOL_STRING)).toBeFalse());
+          })
+          // undefined
+          .it(`${TESTING_UNDEFINED}`, () => expect(isDate(TESTING_UNDEFINED)).toBeFalse())
+          // ... object.
+          .describe(`object`, () => {
+            testing.
+              // BigInt
+              describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isDate(TESTING_BIGINT)).toBeFalse()))
+              // Boolean
+              .describe(`Boolean`, () => {
+                testing
+                  .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isDate(TESTING_TRUE_INSTANCE)).toBeFalse())
+                  .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isDate(TESTING_FALSE_INSTANCE)).toBeFalse());
+              })
+              // Number
+              .describe(`Number`, () =>
+                testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isDate(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+              // String
+              .describe(`String`, () =>
+                testing.it(`new String(${TESTING_STRING})`, () => expect(isDate(TESTING_STRING_INSTANCE)).toBeFalse()));
+          });
+      });
+    });
+});
diff --git a/src/is/test/is-defined.spec.ts b/src/is/test/is-defined.spec.ts
index e859764d..1d709566 100644
--- a/src/is/test/is-defined.spec.ts
+++ b/src/is/test/is-defined.spec.ts
@@ -1,78 +1,96 @@
 // Function.
 import { isDefined } from '../lib/is-defined.func';
-// Constant.
-import { BIGINT, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
-import { notDefined } from '../../testing/src/not-defined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.defined.describe,
+  tests.is.defined.it
+);
 /**
- * Checks
- * ✓ typeof !== 'undefined'
- * ✓ vale !== undefined
+ * Tests.
  */
-describe(isDefined.name, () => {
+testing.describe(isDefined.name, () => {
   // TRUE
-  it('is DEFINED', () => expect(isDefined).toBeDefined());
-  it(`'boolean' | Boolean`, () => {
-    expect(isDefined(FALSE)).toBe(TRUE);
-    expect(isDefined(TRUE)).toBe(TRUE);
-    expect(isDefined(FALSE_INSTANCE)).toBe(TRUE);
-    expect(isDefined(TRUE_INSTANCE)).toBe(TRUE);
-    expect(isDefined(Boolean(false))).toBe(TRUE);
-    expect(isDefined(Boolean(true))).toBe(TRUE);
-    isDefined(FALSE, (result: boolean) => {
-      expect(result).toBe(TRUE);
-      return result;
-    });
-  });
-  it(`'bigint'`, () => {
-    expect(isDefined(BIGINT)).toBe(TRUE);
-    expect(isDefined(BIGINT_INSTANCE)).toBe(TRUE);
-  });
-  it(`Class | CLASS`, () => {
-    expect(isDefined(Class)).toBe(TRUE);
-    expect(isDefined(CLASS)).toBe(TRUE);
-  });
-  it(`'function' | Function`, () => expect(isDefined(FUNCTION)).toBe(TRUE));
-  it(`null | NULL`, () => {
-    expect(isDefined(null)).toBe(TRUE);
-    expect(isDefined(NULL)).toBe(TRUE);
-  });
-  it(`'number' | Number`, () => {
-    expect(isDefined(NUMBER)).toBe(TRUE);
-    expect(isDefined(NUMBER_INSTANCE)).toBe(TRUE);
-    expect(isDefined(NUMBER_NEW_INSTANCE)).toBe(TRUE);
-  });
-  it(`'object' | Object`, () => {
-    expect(isDefined(OBJECT_ONE)).toBe(TRUE);
-    expect(isDefined(OBJECT_TWO)).toBe(TRUE);
-  });
-  it(`'string' | String`, () => {
-    expect(isDefined(STRING)).toBe(TRUE);
-    expect(isDefined(STRING_INSTANCE)).toBe(TRUE);
-    expect(isDefined(STRING_NEW_INSTANCE)).toBe(TRUE);
-  });
-  it(`'symbol'`, () => {
-    expect(isDefined(SYMBOL_NUMBER)).toBe(TRUE);
-    expect(isDefined(SYMBOL_STRING)).toBe(TRUE);
-  });
+  testing
+    .it('is DEFINED', () => expect(isDefined).toBeDefined())
+    .it(`'boolean' | Boolean`, () => {
+      expect(isDefined(TESTING_FALSE)).toBeTrue();
+      expect(isDefined(TESTING_TRUE)).toBeTrue();
+      expect(isDefined(TESTING_FALSE_INSTANCE)).toBeTrue();
+      expect(isDefined(TESTING_TRUE_INSTANCE)).toBeTrue();
+      expect(isDefined(Boolean(false))).toBeTrue();
+      expect(isDefined(Boolean(true))).toBeTrue();
+      isDefined(TESTING_FALSE, (result: boolean) => {
+        expect(result).toBeTrue();
+        return result;
+      });
+    })
+    .it(`'bigint'`, () => expect(isDefined(TESTING_BIGINT)).toBeTrue())
+    .it(`TestingClass | TESTING_CLASS`, () => {
+      expect(isDefined(TestingClass)).toBeTrue();
+      expect(isDefined(TESTING_CLASS)).toBeTrue();
+    })
+    .it(`'function' | Function`, () => expect(isDefined(TESTING_FUNCTION)).toBeTrue())
+    .it(`null | TESTING_NULL`, () => {
+      expect(isDefined(null)).toBeTrue();
+      expect(isDefined(TESTING_NULL)).toBeTrue();
+    })
+    .it(`'number' | Number`, () => {
+      expect(isDefined(TESTING_NUMBER)).toBeTrue();
+      expect(isDefined(TESTING_NUMBER_CONSTRUCTOR)).toBeTrue();
+      expect(isDefined(TESTING_NUMBER_INSTANCE)).toBeTrue();
+    })
+    .it(`'object' | Object`, () => expect(isDefined(TESTING_OBJECT)).toBeTrue())
+    .it(`'string' | String`, () => {
+      expect(isDefined(TESTING_STRING)).toBeTrue();
+      expect(isDefined(TESTING_STRING_CONSTRUCTOR)).toBeTrue();
+      expect(isDefined(TESTING_STRING_INSTANCE)).toBeTrue();
+    })
+    .it(`'symbol'`, () => {
+      expect(isDefined(TESTING_SYMBOL_NUMBER)).toBeTrue();
+      expect(isDefined(TESTING_SYMBOL_STRING)).toBeTrue();
+    })
 
-  // FALSE
-  it(`'undefined'`, () => {
-    expect(isDefined(notDefined)).toBe(FALSE);
-    expect(isDefined(UNDEFINED)).toBe(FALSE);
-    isDefined(UNDEFINED, (result: boolean, value: any) => {
-      expect(result).toEqual(FALSE);
-      expect(value).toBeUndefined();
-      return result;
+    // FALSE
+    .it(`'undefined'`, () => {
+      expect(isDefined(TESTING_UNDEFINED)).toBeFalse();
+      isDefined(TESTING_UNDEFINED, (result, value, payload) => {
+        expect(result).toBeFalse();
+        if (payload) {
+          expect(value).toBeUndefined();
+        }
+        return result;
+      });
     });
-  });
 });
diff --git a/src/is/test/is-false.spec.ts b/src/is/test/is-false.spec.ts
new file mode 100644
index 00000000..9210b7bb
--- /dev/null
+++ b/src/is/test/is-false.spec.ts
@@ -0,0 +1,129 @@
+// Function.
+import { isFalse } from '../lib/is-false.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_DATE,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.false.describe,
+  tests.is.false.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isFalse.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isFalse).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isFalse(TESTING_FALSE, (result: boolean) => {
+            expect(result).toBeTrue();
+            return result;
+          });
+        })
+        // ... arrays.
+        .describe(`array`, () => { })
+        // ... Date.
+        .describe(`date`, () => {
+          testing
+            .it(`TESTING_DATE`, () => expect(isFalse(TESTING_DATE)).toBeFalse())
+        })
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isFalse(TESTING_FUNCTION)).toBeFalse())
+            .it(`TestingClass`, () => expect(isFalse(TestingClass)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isFalse(TESTING_CLASS)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isFalse(TESTING_OBJECT)).toBeFalse())
+            .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isFalse(TESTING_OBJECT)).toBeFalse());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isFalse(TESTING_BIGINT)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isFalse(TESTING_TRUE)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isFalse(TESTING_FALSE)).toBeTrue());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isFalse(TESTING_NULL)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isFalse(TESTING_NUMBER)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isFalse(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isFalse(TESTING_STRING)).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isFalse(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isFalse(TESTING_SYMBOL_NUMBER)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isFalse(TESTING_SYMBOL_STRING)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isFalse(TESTING_UNDEFINED)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => it(`${TESTING_BIGINT}`, () => expect(isFalse(TESTING_BIGINT)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isFalse(TESTING_TRUE_INSTANCE)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isFalse(TESTING_FALSE_INSTANCE)).toBeTrue());
+                })
+                // Number
+                .describe(`Number`, () => it(`new Number(${TESTING_NUMBER})`, () => expect(isFalse(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+                // String
+                .describe(`String`, () => it(`new String(${TESTING_STRING})`, () => expect(isFalse(TESTING_STRING_INSTANCE)).toBeFalse()));
+            });
+        });
+    });
+});
diff --git a/src/is/test/is-function.spec.ts b/src/is/test/is-function.spec.ts
index 6f2f250f..0cf5d060 100644
--- a/src/is/test/is-function.spec.ts
+++ b/src/is/test/is-function.spec.ts
@@ -1,66 +1,88 @@
 // Function.
 import { isFunction } from '../lib/is-function.func';
-// Constant.
-import { BIGINT, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
-import { notDefined } from '../../testing/src/not-defined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(isFunction.name, () => {
-  // TRUE
-  it('is DEFINED', () => expect(isFunction).toBeDefined());
-  it(`'function' | Function`, () => expect(isFunction(FUNCTION)).toBe(TRUE));
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
-  // FALSE.
-  it(`'boolean' | Boolean`, () => {
-    expect(isFunction(FALSE)).toBe(FALSE);
-    expect(isFunction(TRUE)).toBe(FALSE);
-    expect(isFunction(FALSE_INSTANCE)).toBe(FALSE);
-    expect(isFunction(TRUE_INSTANCE)).toBe(FALSE);
-    expect(isFunction(Boolean(false))).toBe(FALSE);
-    expect(isFunction(Boolean(true))).toBe(FALSE);
-    isFunction(TRUE, (result: boolean) => {
-      expect(result).toBe(FALSE);
-      return result;
-    });
-  });
-  it(`'bigint'`, () => {
-    expect(isFunction(BIGINT)).toBe(FALSE);
-    expect(isFunction(BIGINT_INSTANCE)).toBe(FALSE);
-  });
-  it(`CLASS`, () => expect(isFunction(CLASS)).toBe(FALSE));
-  it(`Class`, () => expect(isFunction(Class)).toBe(FALSE));
-  it(`null | NULL`, () => {
-    expect(isFunction(null)).toBe(FALSE);
-    expect(isFunction(NULL)).toBe(FALSE);
-  });
-  it(`'number' | Number`, () => {
-    expect(isFunction(NUMBER)).toBe(FALSE);
-    expect(isFunction(NUMBER_INSTANCE)).toBe(FALSE);
-    expect(isFunction(NUMBER_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'object' | Object`, () => {
-    expect(isFunction(OBJECT_ONE)).toBe(FALSE);
-    expect(isFunction(OBJECT_TWO)).toBe(FALSE);
-  });
-  it(`'string' | String`, () => {
-    expect(isFunction(STRING)).toBe(FALSE);
-    expect(isFunction(STRING_INSTANCE)).toBe(FALSE);
-    expect(isFunction(STRING_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'symbol'`, () => {
-    expect(isFunction(SYMBOL_NUMBER)).toBe(FALSE);
-    expect(isFunction(SYMBOL_STRING)).toBe(FALSE);
-  });
-  it(`'undefined'`, () => {
-    expect(isFunction(notDefined)).toBe(FALSE);
-    expect(isFunction(UNDEFINED)).toBe(FALSE);
-  });
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.function.describe,
+  tests.is.function.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isFunction.name, () => {
+  testing
+    // TRUE
+    .it('is DEFINED', () => expect(isFunction).toBeDefined())
+    .it(`'function' | Function`, () => expect(isFunction(TESTING_FUNCTION)).toBeTrue())
+
+    // FALSE.
+    .it(`'boolean' | Boolean`, () => {
+      expect(isFunction(TESTING_FALSE)).toBeFalse();
+      expect(isFunction(TESTING_TRUE)).toBeFalse();
+      expect(isFunction(TESTING_FALSE_INSTANCE)).toBeFalse();
+      expect(isFunction(TESTING_TRUE_INSTANCE)).toBeFalse();
+      expect(isFunction(Boolean(false))).toBeFalse();
+      expect(isFunction(Boolean(true))).toBeFalse();
+      isFunction(TESTING_TRUE, (result: boolean) => {
+        expect(result).toBeFalse();
+        return result;
+      });
+    })
+    .it(`'bigint'`, () => {
+      expect(isFunction(TESTING_BIGINT)).toBeFalse();
+      expect(isFunction(TESTING_BIGINT)).toBeFalse();
+    })
+    .it(`TESTING_CLASS`, () => expect(isFunction(TESTING_CLASS)).toBeFalse())
+    .it(`TestingClass`, () => expect(isFunction(TestingClass)).toBeFalse())
+    .it(`null | TESTING_NULL`, () => {
+      expect(isFunction(null)).toBeFalse();
+      expect(isFunction(TESTING_NULL)).toBeFalse();
+    })
+    .it(`'number' | Number`, () => {
+      expect(isFunction(TESTING_NUMBER)).toBeFalse();
+      expect(isFunction(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse();
+      expect(isFunction(TESTING_NUMBER_INSTANCE)).toBeFalse();
+    })
+    .it(`'object' | Object`, () => expect(isFunction(TESTING_OBJECT)).toBeFalse())
+    .it(`'string' | String`, () => {
+      expect(isFunction(TESTING_STRING)).toBeFalse();
+      expect(isFunction(TESTING_STRING_CONSTRUCTOR)).toBeFalse();
+      expect(isFunction(TESTING_STRING_INSTANCE)).toBeFalse();
+    })
+    .it(`'symbol'`, () => {
+      expect(isFunction(TESTING_SYMBOL_NUMBER)).toBeFalse();
+      expect(isFunction(TESTING_SYMBOL_STRING)).toBeFalse();
+    })
+    .it(`'undefined'`, () => expect(isFunction(TESTING_UNDEFINED)).toBeFalse());
 });
diff --git a/src/is/test/is-instance.spec.ts b/src/is/test/is-instance.spec.ts
index d3cef598..f258b217 100644
--- a/src/is/test/is-instance.spec.ts
+++ b/src/is/test/is-instance.spec.ts
@@ -1,66 +1,92 @@
 // Function.
 import { isInstance } from '../lib/is-instance.func';
-// Constant.
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../testing/src/boolean.const';
-import { BIGINT, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS, PERSON, Persons, PersonCopy, PERSON_COPY } from '../../testing/src/class.const';
-import { FUNCTION, functionConstructor } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
-import { notDefined } from '../../testing/src/not-defined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_FUNCTION_CONSTRUCTOR,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_PERSON,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+  TestingPerson,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.instance.describe,
+  tests.is.instance.it
+);
 /**
  * Tests.
  */
-describe(isInstance.name, () => {
-  const anyInstance: any = new (functionConstructor as any)('First name', 'Sur name', 27);
-  // TRUE.
-  it('is DEFINED', () => expect(isInstance).toBeDefined());
-  it(`CLASS instance of Class`, () => expect(isInstance(CLASS, Class)).toBe(TRUE));
-  it(`PERSON instance of Person`, () => expect(isInstance(PERSON, Persons)).toBe(TRUE));
-  it(`PERSON_COPY instance of PersonCopy`, () => expect(isInstance(PERSON_COPY, PersonCopy)).toBe(TRUE));
-  it(`CLASS instance of Class expect result to be true`, () => {
-    isInstance(CLASS, Class, (result: boolean) => {
-      expect(result).toBe(TRUE);
-      return result;
-    });
-  });
-  it(`function constructor`, () => expect(isInstance(anyInstance, functionConstructor as any)).toBe(TRUE));
+testing.describe(isInstance.name, () => {
+  const anyInstance: any = new (TESTING_FUNCTION_CONSTRUCTOR as any)('First name', 'Sur name', 27);
+  testing
+    // TRUE.
+    .it('is DEFINED', () => expect(isInstance).toBeDefined())
+    .it(`CLASS instance of Class`, () => expect(isInstance(TESTING_CLASS, TestingClass)).toBeTrue())
+    .it(`PERSON instance of Person`, () => expect(isInstance(TESTING_PERSON, TestingPerson)).toBeTrue())
+    .it(`CLASS instance of Class expect result to be true`, () => {
+      isInstance(TESTING_CLASS, TestingClass, (result: boolean) => {
+        expect(result).toBeTrue();
+        return result;
+      });
+    })
+    .it(`function constructor`, () => expect(isInstance(anyInstance, TESTING_FUNCTION_CONSTRUCTOR as any)).toBeTrue())
 
-  // FALSE.
-  it(`PERSON_COPY not instance of Person`, () => expect(isInstance(PERSON_COPY, Persons)).toBe(FALSE));
-  it(`'boolean' | Boolean`, () => {
-    expect(isInstance(FALSE, FALSE)).toBe(FALSE);
-    expect(isInstance(TRUE, TRUE)).toBe(FALSE);
-    expect(isInstance(FALSE_INSTANCE, FALSE_INSTANCE)).toBe(FALSE);
-    expect(isInstance(TRUE_INSTANCE, TRUE_INSTANCE)).toBe(FALSE);
-  });
-  it(`'bigint'`, () => {
-    expect(isInstance(BIGINT, BIGINT)).toBe(FALSE);
-    expect(isInstance(BIGINT_INSTANCE, BIGINT_INSTANCE)).toBe(FALSE);
-  });
-  it(`Class`, () => expect(isInstance(Class, Class)).toBe(FALSE));
-  it(`FUNCTION instance of Function`, () => expect(isInstance(FUNCTION, Function)).toBe(FALSE));
-  it(`NULL`, () => expect(isInstance(NULL, NULL)).toBe(FALSE));
-  it(`'number' | Number`, () => {
-    expect(isInstance(NUMBER, NUMBER)).toBe(FALSE);
-    expect(isInstance(NUMBER_INSTANCE, NUMBER_INSTANCE)).toBe(FALSE);
-    expect(isInstance(NUMBER_NEW_INSTANCE, NUMBER_NEW_INSTANCE)).toBe(FALSE);
-  });
-  // it(`'object' | Object`, () => {
-  //   expect(isInstance(OBJECT_ONE)).toBe(FALSE);
-  //   expect(isInstance(OBJECT_TWO, OBJECT_TWO)).toBe(FALSE);
-  // });
-  it(`'string' | String`, () => {
-    expect(isInstance(STRING, STRING)).toBe(FALSE);
-    expect(isInstance(STRING_INSTANCE, STRING_INSTANCE)).toBe(FALSE);
-    expect(isInstance(STRING_NEW_INSTANCE, STRING_NEW_INSTANCE)).toBe(FALSE);
-  });
+    // FALSE.
+    .it(`PERSON_COPY not instance of Person`, () => {
+      class TestingPersonCopy {
+        firstName = '';
+        surname = '';
+        age = 15;
+      }
+      expect(isInstance(new TestingPersonCopy(), TestingPerson)).toBeFalse();
+    })
+    .it(`'boolean' | Boolean`, () => {
+      expect(isInstance(TESTING_FALSE, TESTING_FALSE as any)).toBeFalse();
+      expect(isInstance(TESTING_TRUE, TESTING_TRUE as any)).toBeFalse();
+      expect(isInstance(TESTING_FALSE_INSTANCE, TESTING_FALSE_INSTANCE as any)).toBeFalse();
+      expect(isInstance(TESTING_TRUE_INSTANCE, TESTING_TRUE_INSTANCE as any)).toBeFalse();
+    })
+    .it(`'bigint'`, () => expect(isInstance(TESTING_BIGINT, TESTING_BIGINT as any)).toBeFalse())
+    .it(`TestingClass`, () => expect(isInstance(TestingClass, TestingClass)).toBeFalse())
+    .it(`FUNCTION instance of Function`, () => expect(isInstance(TESTING_FUNCTION, Function)).toBeFalse())
+    .it(`NULL`, () => expect(isInstance(TESTING_NULL, TESTING_NULL as any)).toBeFalse())
+    .it(`'number' | Number`, () => {
+      expect(isInstance(TESTING_NUMBER, TESTING_NUMBER as any)).toBeFalse();
+      expect(isInstance(TESTING_NUMBER_INSTANCE, TESTING_NUMBER_CONSTRUCTOR as any)).toBeFalse();
+      expect(isInstance(TESTING_NUMBER_INSTANCE, TESTING_NUMBER_INSTANCE as any)).toBeFalse();
+    })
+    .it(`'object' | Object`, () => expect(isInstance(TESTING_OBJECT, TESTING_OBJECT as any)).toBeFalse())
+    .it(`'string' | String`, () => {
+      expect(isInstance(TESTING_STRING, TESTING_STRING as any)).toBeFalse();
+      expect(isInstance(TESTING_STRING_INSTANCE, TESTING_STRING_CONSTRUCTOR as any)).toBeFalse();
+      expect(isInstance(TESTING_STRING_INSTANCE, TESTING_STRING_INSTANCE as any)).toBeFalse();
+    })
 
-  // FALSE
-  it(`undefined`, () => {
-    expect(isInstance(notDefined, notDefined)).toBe(FALSE);
-    expect(isInstance(UNDEFINED, UNDEFINED)).toBe(FALSE);
-  });
+    // FALSE
+    .it(`undefined`, () => expect(isInstance(TESTING_UNDEFINED, TESTING_UNDEFINED as any)).toBeFalse());
 });
diff --git a/src/is/test/is-key.spec.ts b/src/is/test/is-key.spec.ts
index f0b2bb9e..72d65e12 100644
--- a/src/is/test/is-key.spec.ts
+++ b/src/is/test/is-key.spec.ts
@@ -1,89 +1,125 @@
 // Function.
 import { isKey } from '../lib/is-key.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(isKey.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isKey).toBeDefined());
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isKey('test', (result: boolean) => {
-        expect(result).toBe(TRUE);
-        return result;
-      });
-    });
-    // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isKey(FUNCTION, 'function')).toBe(FALSE));
-      // it(`${Class}`, () => expect(isKey(Class, 'function')).toBe(FALSE));
-    });
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isKey(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isKey(Class)).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isKey(CLASS)).toBe(FALSE));
-      it(`OBJECT_ONE`, () => expect(isKey(OBJECT_ONE)).toBe(FALSE));
-      it(`OBJECT_TWO`, () => expect(isKey(OBJECT_TWO)).toBe(FALSE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isKey(OBJECT_ONE_NEW)).toBe(FALSE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isKey(OBJECT_TWO_NEW)).toBe(FALSE));
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isKey(BIGINT)).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isKey(TRUE)).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isKey(FALSE)).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isKey(NULL)).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isKey(NUMBER)).toBe(TRUE));
-        it(`Number(${NUMBER})`, () => expect(isKey(NUMBER_INSTANCE)).toBe(TRUE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isKey(STRING)).toBe(TRUE));
-        it(`String(${STRING})`, () => expect(isKey(STRING_INSTANCE)).toBe(TRUE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isKey(SYMBOL_NUMBER)).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(isKey(SYMBOL_STRING)).toBe(TRUE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isKey(UNDEFINED)).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isKey(BIGINT_INSTANCE)).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isKey(TRUE_INSTANCE)).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isKey(FALSE_INSTANCE)).toBe(FALSE));
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.key.describe,
+  tests.is.key.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isKey.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isKey).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isKey('test', (result: boolean) => {
+            expect(result).toBeTrue();
+            return result;
+          });
+        })
+        // ... arrays.
+        .describe(`array`, () => { })
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isKey(TESTING_FUNCTION)).toBeFalse())
+            .it(`TestingClass`, () => expect(isKey(TestingClass)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isKey(TESTING_CLASS)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isKey(TESTING_OBJECT)).toBeFalse())
+            .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isKey(TESTING_OBJECT)).toBeFalse());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isKey(TESTING_BIGINT)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isKey(TESTING_TRUE)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isKey(TESTING_FALSE)).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isKey(TESTING_NULL)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isKey(TESTING_NUMBER)).toBeTrue())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isKey(TESTING_NUMBER_CONSTRUCTOR)).toBeTrue());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isKey(TESTING_STRING)).toBeTrue())
+                .it(`String(${TESTING_STRING})`, () => expect(isKey(TESTING_STRING_CONSTRUCTOR)).toBeTrue());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isKey(TESTING_SYMBOL_NUMBER)).toBeTrue())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isKey(TESTING_SYMBOL_STRING)).toBeTrue());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isKey(TESTING_UNDEFINED)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isKey(TESTING_BIGINT)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isKey(TESTING_TRUE_INSTANCE)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isKey(TESTING_FALSE_INSTANCE)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isKey(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isKey(TESTING_STRING_INSTANCE)).toBeFalse()));
+            });
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isKey(NUMBER_NEW_INSTANCE)).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isKey(STRING_NEW_INSTANCE)).toBe(FALSE)));
-      });
     });
-  });
 });
diff --git a/src/is/test/is-null.spec.ts b/src/is/test/is-null.spec.ts
index e4e9c8d9..555d3039 100644
--- a/src/is/test/is-null.spec.ts
+++ b/src/is/test/is-null.spec.ts
@@ -1,69 +1,91 @@
-
 // Function.
 import { isNull } from '../lib/is-null.func';
-// Constant.
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../testing/src/boolean.const';
-import { BIGINT, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
-import { notDefined } from '../../testing/src/not-defined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(isNull.name, () => {
-  // TRUE
-  it('is DEFINED', () => expect(isNull).toBeDefined());
-  it(`null | NULL`, () => {
-    expect(isNull(null)).toBe(TRUE);
-    expect(isNull(NULL)).toBe(TRUE);
-    isNull(NULL, (result: boolean) => {
-      expect(result).toBe(TRUE);
-      return result;
-    });
-  });
+  // Constants.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
-  // FALSE
-  it(`'bigint'`, () => {
-    expect(isNull(BIGINT)).toBe(FALSE);
-    expect(isNull(BIGINT_INSTANCE)).toBe(FALSE);
-  });
-  it(`'boolean' | Boolean`, () => {
-    expect(isNull(FALSE)).toBe(FALSE);
-    expect(isNull(TRUE)).toBe(FALSE);
-    expect(isNull(FALSE_INSTANCE)).toBe(FALSE);
-    expect(isNull(TRUE_INSTANCE)).toBe(FALSE);
-    expect(isNull(Boolean(false))).toBe(FALSE);
-    expect(isNull(Boolean(true))).toBe(FALSE);
-  });
-  it(`Class | CLASS`, () => {
-    expect(isNull(Class)).toBe(FALSE);
-    expect(isNull(CLASS)).toBe(FALSE);
-  });
-  it(`'function' | Function`, () => expect(isNull(FUNCTION)).toBe(FALSE));
-  it(`'number' | Number`, () => {
-    expect(isNull(NUMBER)).toBe(FALSE);
-    expect(isNull(NUMBER_INSTANCE)).toBe(FALSE);
-    expect(isNull(NUMBER_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'object' | Object`, () => {
-    expect(isNull(OBJECT_ONE)).toBe(FALSE);
-    expect(isNull(OBJECT_TWO)).toBe(FALSE);
-  });
-  it(`'string' | String`, () => {
-    expect(isNull(STRING)).toBe(FALSE);
-    expect(isNull(STRING_INSTANCE)).toBe(FALSE);
-    expect(isNull(STRING_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'symbol'`, () => {
-    expect(isNull(SYMBOL_NUMBER)).toBe(FALSE);
-    expect(isNull(SYMBOL_STRING)).toBe(FALSE);
-  });
-  it(`'undefined'`, () => {
-    expect(isNull(notDefined)).toBe(FALSE);
-    expect(isNull(UNDEFINED)).toBe(FALSE);
-  });
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.null.describe,
+  tests.is.null.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isNull.name, () => {
+  testing
+    // TRUE
+    .it('is DEFINED', () => expect(isNull).toBeDefined())
+    .it(`null | TESTING_NULL`, () => {
+      expect(isNull(null)).toBeTrue();
+      expect(isNull(TESTING_NULL)).toBeTrue();
+      isNull(TESTING_NULL, (result: boolean) => {
+        expect(result).toBeTrue();
+        return result;
+      });
+    })
+    // FALSE
+    .it(`'bigint'`, () => {
+      expect(isNull(TESTING_BIGINT)).toBeFalse();
+      expect(isNull(TESTING_BIGINT)).toBeFalse();
+    })
+    .it(`'boolean' | Boolean`, () => {
+      expect(isNull(TESTING_FALSE)).toBeFalse();
+      expect(isNull(TESTING_TRUE)).toBeFalse();
+      expect(isNull(TESTING_FALSE_INSTANCE)).toBeFalse();
+      expect(isNull(TESTING_TRUE_INSTANCE)).toBeFalse();
+      expect(isNull(Boolean(false))).toBeFalse();
+      expect(isNull(Boolean(true))).toBeFalse();
+    })
+    .it(`TestingClass | TESTING_CLASS`, () => {
+      expect(isNull(TestingClass)).toBeFalse();
+      expect(isNull(TESTING_CLASS)).toBeFalse();
+    })
+    .it(`'function' | Function`, () => expect(isNull(TESTING_FUNCTION)).toBeFalse())
+    .it(`'number' | Number`, () => {
+      expect(isNull(TESTING_NUMBER)).toBeFalse();
+      expect(isNull(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse();
+      expect(isNull(TESTING_NUMBER_INSTANCE)).toBeFalse();
+    })
+    .it(`'object' | Object`, () => expect(isNull(TESTING_OBJECT)).toBeFalse())
+    .it(`'string' | String`, () => {
+      expect(isNull(TESTING_STRING)).toBeFalse();
+      expect(isNull(TESTING_STRING_CONSTRUCTOR)).toBeFalse();
+      expect(isNull(TESTING_STRING_INSTANCE)).toBeFalse();
+    })
+    .it(`'symbol'`, () => {
+      expect(isNull(TESTING_SYMBOL_NUMBER)).toBeFalse();
+      expect(isNull(TESTING_SYMBOL_STRING)).toBeFalse();
+    })
+    .it(`'undefined'`, () => {
+      expect(isNull(TESTING_UNDEFINED)).toBeFalse();
+    });
 });
diff --git a/src/is/test/is-number-between.spec.ts b/src/is/test/is-number-between.spec.ts
new file mode 100644
index 00000000..ba9c1353
--- /dev/null
+++ b/src/is/test/is-number-between.spec.ts
@@ -0,0 +1,138 @@
+// Function.
+import { isNumberBetween } from '../lib/is-number-between.func';
+// Testing.
+import {
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_DATE,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  Testing,
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.numberBetween.describe,
+  tests.is.numberBetween.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isNumberBetween.name, () => {
+  // Constant.
+  const min = 0;
+  const max = 13;
+  const value = 13;
+
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isNumberBetween).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isNumberBetween(TESTING_FALSE,  min, max, (result: boolean) => {
+            expect(result).toBeFalse();
+            return result;
+          });
+        })
+        // ... arrays.
+        .describe(`array`, () => { })
+        // ... Date.
+        .describe(`date`, () => {
+          testing
+          .it(`TESTING_DATE`, () => expect(isNumberBetween(TESTING_DATE,  min, max)).toBeFalse());
+        })
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isNumberBetween(TESTING_FUNCTION,  min, max)).toBeFalse())
+            .it(`TestingClass`, () => expect(isNumberBetween(TestingClass,  min, max)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isNumberBetween(TESTING_CLASS,  min, max)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isNumberBetween(TESTING_OBJECT,  min, max)).toBeFalse());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () =>
+              testing.it(`${TESTING_BIGINT}`, () => expect(isNumberBetween(TESTING_BIGINT,  min, max)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isNumberBetween(TESTING_TRUE,  min, max)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isNumberBetween(TESTING_FALSE,  min, max)).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isNumberBetween(TESTING_NULL,  min, max)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isNumberBetween(TESTING_NUMBER,  min, max)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isNumberBetween(TESTING_NUMBER_INSTANCE,  min, max)).toBeFalse())
+                .it(`${TESTING_NUMBER}`, () => expect(isNumberBetween(value,  min, max)).toBeTrue());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isNumberBetween(TESTING_STRING,  min, max)).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isNumberBetween(TESTING_STRING_INSTANCE,  min, max)).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isNumberBetween(TESTING_SYMBOL_NUMBER,  min, max)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isNumberBetween(TESTING_SYMBOL_STRING,  min, max)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isNumberBetween(TESTING_UNDEFINED,  min, max)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () =>
+                  testing.it(`${TESTING_BIGINT}`, () => expect(isNumberBetween(TESTING_BIGINT,  min, max)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isNumberBetween(TESTING_TRUE_INSTANCE,  min, max)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isNumberBetween(TESTING_FALSE_INSTANCE,  min, max)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () => {
+                  testing
+                    .it(`new Number(${TESTING_NUMBER})`, () => expect(isNumberBetween(TESTING_NUMBER_INSTANCE,  min, max)).toBeFalse())
+                    .it(`new Number(${value})`, () => expect(isNumberBetween(new Number(value),  min, max)).toBeTrue())
+                    .it(`new Number(${value})`, () => expect(isNumberBetween(new Number(1.15),  min, max)).toBeTrue())
+                    .it(`new Number(${value})`, () => expect(isNumberBetween(new Number(13.15),  min, max)).toBeFalse());
+                })
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () =>
+                    expect(isNumberBetween(TESTING_STRING_INSTANCE,  min, max)).toBeFalse()));
+            });
+        });
+    });
+});
diff --git a/src/is/test/is-number-object.spec.ts b/src/is/test/is-number-object.spec.ts
index 427348d4..371eb443 100644
--- a/src/is/test/is-number-object.spec.ts
+++ b/src/is/test/is-number-object.spec.ts
@@ -1,93 +1,120 @@
 // Function.
 import { isNumberObject } from '../lib/is-number-object.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
+  Testing,
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.numberObject.describe,
+  tests.is.numberObject.it
+);
 /**
  * Checks
  * ✓ typeof === 'object' && instanceof Number === true && instanceof Object === true
  */
-describe(isNumberObject.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isNumberObject).toBeDefined());
+testing.describe(isNumberObject.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isNumberObject).toBeDefined())
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isNumberObject(NUMBER_NEW_INSTANCE, (result: boolean) => {
-        expect(result).toBe(TRUE);
-        return result;
-      });
-    });
-    // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isNumberObject(FUNCTION, 'function')).toBe(FALSE));
-      // it(`${Class}`, () => expect(isNumberObject(Class, 'function')).toBe(FALSE));
-    });
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isNumberObject(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isNumberObject(Class)).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isNumberObject(CLASS)).toBe(FALSE));
-      it(`OBJECT_ONE`, () => expect(isNumberObject(OBJECT_ONE)).toBe(FALSE));
-      it(`OBJECT_TWO`, () => expect(isNumberObject(OBJECT_TWO)).toBe(FALSE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isNumberObject(OBJECT_ONE_NEW)).toBe(FALSE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isNumberObject(OBJECT_TWO_NEW)).toBe(FALSE));
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isNumberObject(BIGINT)).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isNumberObject(TRUE)).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isNumberObject(FALSE)).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isNumberObject(NULL)).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isNumberObject(NUMBER)).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isNumberObject(NUMBER_INSTANCE)).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isNumberObject(STRING)).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isNumberObject(STRING_INSTANCE)).toBe(FALSE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isNumberObject(SYMBOL_NUMBER)).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isNumberObject(SYMBOL_STRING)).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isNumberObject(UNDEFINED)).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isNumberObject(BIGINT_INSTANCE)).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isNumberObject(TRUE_INSTANCE)).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isNumberObject(FALSE_INSTANCE)).toBe(FALSE));
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isNumberObject(TESTING_NUMBER_INSTANCE, (result: boolean) => {
+            expect(result).toBeTrue();
+            return result;
+          });
+        })
+        // ... arrays.
+        .describe(`array`, () => { })
+        // ... function.
+        .describe(`function`, () => testing
+          .it(`TESTING_FUNCTION`, () => expect(isNumberObject(TESTING_FUNCTION)).toBeFalse())
+          .it(`TestingClass`, () => expect(isNumberObject(TestingClass)).toBeFalse())
+        )
+        // ... objects.
+        .describe('object', () => testing
+          .it(`TESTING_CLASS`, () => expect(isNumberObject(TESTING_CLASS)).toBeFalse())
+          .it(`TESTING_OBJECT`, () => expect(isNumberObject(TESTING_OBJECT)).toBeFalse())
+          .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isNumberObject(TESTING_OBJECT)).toBeFalse())
+        )
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isNumberObject(TESTING_BIGINT)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isNumberObject(TESTING_TRUE)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isNumberObject(TESTING_FALSE)).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isNumberObject(TESTING_NULL)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isNumberObject(TESTING_NUMBER)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isNumberObject(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isNumberObject(TESTING_STRING)).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isNumberObject(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isNumberObject(TESTING_SYMBOL_NUMBER)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isNumberObject(TESTING_SYMBOL_STRING)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isNumberObject(TESTING_UNDEFINED)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isNumberObject(TESTING_BIGINT)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isNumberObject(TESTING_TRUE_INSTANCE)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isNumberObject(TESTING_FALSE_INSTANCE)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isNumberObject(TESTING_NUMBER_INSTANCE)).toBeTrue()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isNumberObject(TESTING_STRING_INSTANCE)).toBeFalse()));
+            });
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isNumberObject(NUMBER_NEW_INSTANCE)).toBe(TRUE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isNumberObject(STRING_NEW_INSTANCE)).toBe(FALSE)));
-      });
     });
-  });
 });
diff --git a/src/is/test/is-number-type.spec.ts b/src/is/test/is-number-type.spec.ts
index a09348c9..b61fb1bd 100644
--- a/src/is/test/is-number-type.spec.ts
+++ b/src/is/test/is-number-type.spec.ts
@@ -1,95 +1,124 @@
 // Function.
 import { isNumberType } from '../lib/is-number-type.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
+  Testing,
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.numberType.describe,
+  tests.is.numberType.it
+);
 /**
  * Checks
  * ✓ typeof === 'number' && instanceof Number === false && instanceof Object === false
  * ✓ value === true
  * ✓ value === false
  */
-describe(isNumberType.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isNumberType).toBeDefined());
+testing.describe(isNumberType.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isNumberType).toBeDefined())
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isNumberType(NUMBER, (result: boolean) => {
-        expect(result).toBe(TRUE);
-        return result;
-      });
-    });
-    // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isNumberType(FUNCTION, 'function')).toBe(FALSE));
-      // it(`${Class}`, () => expect(isNumberType(Class, 'function')).toBe(FALSE));
-    });
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isNumberType(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isNumberType(Class)).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isNumberType(CLASS)).toBe(FALSE));
-      it(`OBJECT_ONE`, () => expect(isNumberType(OBJECT_ONE)).toBe(FALSE));
-      it(`OBJECT_TWO`, () => expect(isNumberType(OBJECT_TWO)).toBe(FALSE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isNumberType(OBJECT_ONE_NEW)).toBe(FALSE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isNumberType(OBJECT_TWO_NEW)).toBe(FALSE));
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isNumberType(BIGINT)).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isNumberType(TRUE)).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isNumberType(FALSE)).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isNumberType(NULL)).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isNumberType(NUMBER)).toBe(TRUE));
-        it(`Number(${NUMBER})`, () => expect(isNumberType(NUMBER_INSTANCE)).toBe(TRUE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isNumberType(STRING)).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isNumberType(STRING_INSTANCE)).toBe(FALSE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isNumberType(SYMBOL_NUMBER)).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isNumberType(SYMBOL_STRING)).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isNumberType(UNDEFINED)).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isNumberType(BIGINT_INSTANCE)).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isNumberType(TRUE_INSTANCE)).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isNumberType(FALSE_INSTANCE)).toBe(FALSE));
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isNumberType(TESTING_NUMBER, (result: boolean) => {
+            expect(result).toBeTrue();
+            return result;
+          });
+        })
+        // ... arrays.
+        .describe(`array`, () => { })
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isNumberType(TESTING_FUNCTION)).toBeFalse())
+            .it(`TestingClass`, () => expect(isNumberType(TestingClass)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isNumberType(TESTING_CLASS)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isNumberType(TESTING_OBJECT)).toBeFalse())
+            .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isNumberType(TESTING_OBJECT)).toBeFalse())
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isNumberType(TESTING_BIGINT)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isNumberType(TESTING_TRUE)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isNumberType(TESTING_FALSE)).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isNumberType(TESTING_NULL)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isNumberType(TESTING_NUMBER)).toBeTrue())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isNumberType(TESTING_NUMBER_CONSTRUCTOR)).toBeTrue());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isNumberType(TESTING_STRING)).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isNumberType(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isNumberType(TESTING_SYMBOL_NUMBER)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isNumberType(TESTING_SYMBOL_STRING)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isNumberType(TESTING_UNDEFINED)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isNumberType(TESTING_BIGINT)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isNumberType(TESTING_TRUE_INSTANCE)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isNumberType(TESTING_FALSE_INSTANCE)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isNumberType(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isNumberType(TESTING_STRING_INSTANCE)).toBeFalse()));
+            });
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isNumberType(NUMBER_NEW_INSTANCE)).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isNumberType(STRING_NEW_INSTANCE)).toBe(FALSE)));
-      });
     });
-  });
 });
diff --git a/src/is/test/is-number.spec.ts b/src/is/test/is-number.spec.ts
index e390f965..0e1ac0f9 100644
--- a/src/is/test/is-number.spec.ts
+++ b/src/is/test/is-number.spec.ts
@@ -1,17 +1,37 @@
 // Function.
 import { isNumber } from '../lib/is-number.func';
-// Type.
-import { BIGINT, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { CLASS, Class } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
-import { notDefined } from '../../testing/src/not-defined.const';
+// Testing.
+import {
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  Testing,
+  TestingClass,
+} from '@angular-package/testing';
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.number.describe,
+  tests.is.number.it
+);
 /**
  * Checks
  * ✓ typeof === 'number'
@@ -20,54 +40,49 @@ import { notDefined } from '../../testing/src/not-defined.const';
  * ✓ typeof === 'object'
  * ✓ instanceof Object
  */
-describe(isNumber.name, () => {
-  // TRUE
-  it('is DEFINED', () => expect(isNumber).toBeDefined());
-  it(`'number' | Number`, () => {
-    expect(isNumber(NUMBER)).toBe(TRUE);
-    expect(isNumber(NUMBER_INSTANCE)).toBe(TRUE);
-    expect(isNumber(NUMBER_NEW_INSTANCE)).toBe(TRUE);
-    isNumber(NUMBER_NEW_INSTANCE, (result: boolean) => {
-      expect(result).toBe(TRUE);
-      return result;
-    });
-  });
+testing.describe(isNumber.name, () => {
+  testing
+    // TRUE
+    .it('is DEFINED', () => expect(isNumber).toBeDefined())
+    .it(`'number' | Number`, () => {
+      expect(isNumber(TESTING_NUMBER)).toBeTrue();
+      expect(isNumber(TESTING_NUMBER_CONSTRUCTOR)).toBeTrue();
+      expect(isNumber(TESTING_NUMBER_INSTANCE)).toBeTrue();
+      isNumber(TESTING_NUMBER_INSTANCE, (result: boolean) => {
+        expect(result).toBeTrue();
+        return result;
+      });
+    })
 
-  // FALSE
-  it(`'bigint'`, () => {
-    expect(isNumber(BIGINT)).toBe(FALSE);
-    expect(isNumber(BIGINT_INSTANCE)).toBe(FALSE);
-  });
-  it(`'boolean' | Boolean`, () => {
-    expect(isNumber(FALSE)).toBe(FALSE);
-    expect(isNumber(TRUE)).toBe(FALSE);
-    expect(isNumber(FALSE_INSTANCE)).toBe(FALSE);
-    expect(isNumber(TRUE_INSTANCE)).toBe(FALSE);
-  });
-  it(`Class | CLASS`, () => {
-    expect(isNumber(Class)).toBe(FALSE);
-    expect(isNumber(CLASS)).toBe(FALSE);
-  });
-  it(`'function' | Function`, () => expect(isNumber(FUNCTION)).toBe(FALSE));
-  it(`null | NULL`, () => {
-    expect(isNumber(null)).toBe(FALSE);
-    expect(isNumber(NULL)).toBe(FALSE);
-  });
-  it(`'object' | Object`, () => {
-    expect(isNumber(OBJECT_ONE)).toBe(FALSE);
-    expect(isNumber(OBJECT_TWO)).toBe(FALSE);
-  });
-  it(`'string' | String`, () => {
-    expect(isNumber(STRING)).toBe(FALSE);
-    expect(isNumber(STRING_INSTANCE)).toBe(FALSE);
-    expect(isNumber(STRING_NEW_INSTANCE)).toBe(FALSE);
-  });
-  it(`'symbol'`, () => {
-    expect(isNumber(SYMBOL_NUMBER)).toBe(FALSE);
-    expect(isNumber(SYMBOL_STRING)).toBe(FALSE);
-  });
-  it(`'undefined'`, () => {
-    expect(isNumber(notDefined)).toBe(FALSE);
-    expect(isNumber(UNDEFINED)).toBe(FALSE);
-  });
+    // FALSE
+    .it(`'bigint'`, () => {
+      expect(isNumber(TESTING_BIGINT)).toBeFalse();
+      expect(isNumber(TESTING_BIGINT)).toBeFalse();
+    })
+    .it(`'boolean' | Boolean`, () => {
+      expect(isNumber(TESTING_FALSE)).toBeFalse();
+      expect(isNumber(TESTING_TRUE)).toBeFalse();
+      expect(isNumber(TESTING_FALSE_INSTANCE)).toBeFalse();
+      expect(isNumber(TESTING_TRUE_INSTANCE)).toBeFalse();
+    })
+    .it(`TestingClass | TESTING_CLASS`, () => {
+      expect(isNumber(TestingClass)).toBeFalse();
+      expect(isNumber(TESTING_CLASS)).toBeFalse();
+    })
+    .it(`'function' | Function`, () => expect(isNumber(TESTING_FUNCTION)).toBeFalse())
+    .it(`null | TESTING_NULL`, () => {
+      expect(isNumber(null)).toBeFalse();
+      expect(isNumber(TESTING_NULL)).toBeFalse();
+    })
+    .it(`'object' | Object`, () => expect(isNumber(TESTING_OBJECT)).toBeFalse())
+    .it(`'string' | String`, () => {
+      expect(isNumber(TESTING_STRING)).toBeFalse();
+      expect(isNumber(TESTING_STRING_CONSTRUCTOR)).toBeFalse();
+      expect(isNumber(TESTING_STRING_INSTANCE)).toBeFalse();
+    })
+    .it(`'symbol'`, () => {
+      expect(isNumber(TESTING_SYMBOL_NUMBER)).toBeFalse();
+      expect(isNumber(TESTING_SYMBOL_STRING)).toBeFalse();
+    })
+    .it(`'undefined'`, () => expect(isNumber(TESTING_UNDEFINED)).toBeFalse());
 });
diff --git a/src/is/test/is-object-key-in.spec.ts b/src/is/test/is-object-key-in.spec.ts
index 305cf8db..627b8d09 100644
--- a/src/is/test/is-object-key-in.spec.ts
+++ b/src/is/test/is-object-key-in.spec.ts
@@ -1,141 +1,152 @@
 // Function.
 import { isObjectKeyIn } from '../lib/is-object-key-in.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, TRUE_INSTANCE, FALSE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/strict/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(isObjectKeyIn.name , () => {
-  // Defined.
-  it('is DEFINED', () => expect(isObjectKeyIn).toBeDefined());
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isObjectKeyIn(CLASS, ['firstName', 'surname'], (result: boolean, value: Class) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(CLASS);
-        return result;
-      });
-    });
-    // ... instance.
-    describe(`instance`, () => {
-      describe(`CLASS`, () => {
-        // number.
-        it('has number key', () => {
-          expect(isObjectKeyIn(CLASS, 1030405027)).toBe(TRUE);
-          expect(isObjectKeyIn(CLASS, 5)).toBe(TRUE);
-          expect(isObjectKeyIn(CLASS, NUMBER)).toBe(TRUE); // It does find getter number
-          expect(isObjectKeyIn(CLASS, [5, 1030405027])).toBe(TRUE);
-        });
-        // string.
-        it('has string key', () => {
-          expect(isObjectKeyIn(CLASS, 'surname')).toBe(TRUE);
-          expect(isObjectKeyIn(CLASS, ['firstName', 'surname'])).toBe(TRUE);
-        });
-        // symbol.
-        it('has getter symbol key', () => {
-          // It does find getter symbol key
-          expect(isObjectKeyIn(CLASS, SYMBOL_NUMBER)).toBe(TRUE);
-          expect(isObjectKeyIn(CLASS, SYMBOL_STRING)).toBe(TRUE);
-          expect(isObjectKeyIn(CLASS, [SYMBOL_NUMBER, SYMBOL_STRING])).toBe(TRUE);
-        });
-        // mixed.
-        it('has string and number key', () => expect(isObjectKeyIn(CLASS, [1030405027, 'firstName', 'surname'])).toBe(TRUE));
-      });
-    });
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isObjectKeyIn(FUNCTION, 'function')).toBe(FALSE));
-      it(`CLASS`, () => expect(isObjectKeyIn(Class, 'function')).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      describe(`OBJECT_ONE`, () => {
-        // number.
-        it('has number key', () => {
-          expect(isObjectKeyIn(OBJECT_ONE, 1030405027)).toBe(TRUE);
-          expect(isObjectKeyIn(OBJECT_ONE, 5)).toBe(TRUE);
-          expect(isObjectKeyIn(OBJECT_ONE, NUMBER)).toBe(TRUE); // It doesn't find getter
-          expect(isObjectKeyIn(OBJECT_ONE, [5, 1030405027])).toBe(TRUE);
-        });
-        // string.
-        it('has string key', () => {
-          expect(isObjectKeyIn(OBJECT_ONE, 'key as string')).toBe(TRUE);
-          expect(isObjectKeyIn(OBJECT_ONE, 'x')).toBe(TRUE);
-          expect(isObjectKeyIn(OBJECT_ONE, STRING)).toBe(TRUE);
-          expect(isObjectKeyIn(OBJECT_ONE, ['key as string', 'x', STRING])).toBe(TRUE);
-        });
-        // symbol.
-        it('has symbol key', () => {
-          expect(isObjectKeyIn(OBJECT_ONE, SYMBOL_NUMBER)).toBe(TRUE);
-          expect(isObjectKeyIn(OBJECT_ONE, SYMBOL_STRING)).toBe(TRUE);
-          expect(isObjectKeyIn(OBJECT_ONE, [SYMBOL_NUMBER, SYMBOL_STRING])).toBe(TRUE);
-        });
-        // mixed.
-        it('has mixed key', () => {
-          expect(isObjectKeyIn(OBJECT_ONE, [
-            'key as string',
-            'x',
-            1030405027,
-            5,
-            NUMBER,
-            STRING,
-            SYMBOL_NUMBER,
-            SYMBOL_STRING,
-          ])).toBe(TRUE);
-        });
-      });
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isObjectKeyIn(BIGINT, 'bigint')).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isObjectKeyIn(TRUE, 'boolean')).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isObjectKeyIn(FALSE, 'boolean')).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isObjectKeyIn(NULL, 'null')).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isObjectKeyIn(NUMBER, 'number')).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isObjectKeyIn(NUMBER_INSTANCE, 'number')).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isObjectKeyIn(STRING, 'string')).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isObjectKeyIn(STRING_INSTANCE, 'string')).toBe(FALSE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isObjectKeyIn(SYMBOL_NUMBER, 'symbol')).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isObjectKeyIn(SYMBOL_STRING, 'symbol')).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isObjectKeyIn(UNDEFINED, 'undefined')).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isObjectKeyIn(BIGINT_INSTANCE, 'bigint')).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isObjectKeyIn(TRUE_INSTANCE, 'boolean')).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isObjectKeyIn(FALSE_INSTANCE, 'boolean')).toBe(FALSE));
-        });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isObjectKeyIn(NUMBER_NEW_INSTANCE, 'number')).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isObjectKeyIn(STRING_NEW_INSTANCE, 'string')).toBe(FALSE)));
-      });
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.objectKeyIn.describe,
+  tests.is.objectKeyIn.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isObjectKeyIn.name , () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isObjectKeyIn).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isObjectKeyIn(TESTING_CLASS, 'firstName', (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_CLASS);
+            }
+            return result;
+          });
+        })
+        // ... instance.
+        .describe(`instance`, () => testing
+          .describe(`TESTING_CLASS`, () => testing
+            // number.
+            .it('has number key', () => {
+              expect(isObjectKeyIn(TESTING_CLASS, 1030405027)).toBeTrue();
+              expect(isObjectKeyIn(TESTING_CLASS, 5)).toBeTrue();
+              expect(isObjectKeyIn(TESTING_CLASS, TESTING_NUMBER)).toBeTrue(); // It does find getter number
+            })
+            // string.
+            .it('has string key', () => {
+              expect(isObjectKeyIn(TESTING_CLASS, 'surname')).toBeTrue();
+            })
+            // symbol.
+            .it('has getter symbol key', () => {
+              // It does find getter symbol key
+              expect(isObjectKeyIn(TESTING_CLASS, TESTING_SYMBOL_NUMBER)).toBeTrue();
+              expect(isObjectKeyIn(TESTING_CLASS, TESTING_SYMBOL_STRING)).toBeTrue();
+            })
+          )
+        )
+        // ... function.
+        .describe(`function`, () => testing
+          .it(`TESTING_FUNCTION`, () => expect(isObjectKeyIn(TESTING_FUNCTION, 'function')).toBeFalse())
+          .it(`TESTING_CLASS`, () => expect(isObjectKeyIn(TestingClass, 'function')).toBeFalse())
+        )
+        // ... objects.
+        .describe('object', () => testing
+          .describe(`TESTING_OBJECT`, () => testing
+            // number.
+            .it('has number key', () => {
+              expect(isObjectKeyIn(TESTING_OBJECT, 1030405027)).toBeTrue();
+              expect(isObjectKeyIn(TESTING_OBJECT, 5)).toBeTrue();
+              expect(isObjectKeyIn(TESTING_OBJECT, TESTING_NUMBER)).toBeTrue(); // It doesn't find getter
+            })
+            // string.
+            .it('has string key', () => {
+              expect(isObjectKeyIn(TESTING_OBJECT, 'key as string')).toBeTrue();
+              expect(isObjectKeyIn(TESTING_OBJECT, 'x')).toBeTrue();
+              expect(isObjectKeyIn(TESTING_OBJECT, TESTING_STRING)).toBeTrue();
+            })
+            // symbol.
+            .it('has symbol key', () => {
+              expect(isObjectKeyIn(TESTING_OBJECT, TESTING_SYMBOL_NUMBER)).toBeTrue();
+              expect(isObjectKeyIn(TESTING_OBJECT, TESTING_SYMBOL_STRING)).toBeTrue();
+            })
+          )
+        )
+        // ... primitives.
+        .describe(`primitive`, () => testing
+          // bigint
+          .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isObjectKeyIn(TESTING_BIGINT, 'bigint')).toBeFalse()))
+          // boolean
+          .describe(`boolean`, () => testing
+            .it(`${TESTING_TRUE}`, () => expect(isObjectKeyIn(TESTING_TRUE, 'boolean')).toBeFalse())
+            .it(`${TESTING_FALSE}`, () => expect(isObjectKeyIn(TESTING_FALSE, 'boolean')).toBeFalse())
+          )
+          // null
+          .it(`${TESTING_NULL}`, () => expect(isObjectKeyIn(TESTING_NULL, 'null')).toBeFalse())
+          // number
+          .describe(`number`, () => testing
+            .it(`${TESTING_NUMBER}`, () => expect(isObjectKeyIn(TESTING_NUMBER, 'number')).toBeFalse())
+            .it(`Number(${TESTING_NUMBER})`, () => expect(isObjectKeyIn(TESTING_NUMBER_INSTANCE, 'number')).toBeFalse())
+          )
+          // string
+          .describe(`string`, () => testing
+            .it(`${TESTING_STRING}`, () => expect(isObjectKeyIn(TESTING_STRING, 'string')).toBeFalse())
+            .it(`String(${TESTING_STRING})`, () => expect(isObjectKeyIn(TESTING_STRING_INSTANCE, 'string')).toBeFalse())
+          )
+          // symbol
+          .describe(`symbol`, () => testing
+            .it(`Symbol(${TESTING_NUMBER})`, () => expect(isObjectKeyIn(TESTING_SYMBOL_NUMBER, 'symbol')).toBeFalse())
+            .it(`Symbol(${TESTING_STRING})`, () => expect(isObjectKeyIn(TESTING_SYMBOL_STRING, 'symbol')).toBeFalse())
+          )
+          // undefined
+          .it(`${TESTING_UNDEFINED}`, () => expect(isObjectKeyIn(TESTING_UNDEFINED, 'undefined')).toBeFalse())
+          // ... object.
+          .describe(`object`, () => testing
+            // BigInt
+            .describe(`BigInt`, () =>
+              testing.it(`${TESTING_BIGINT}`, () => expect(isObjectKeyIn(TESTING_BIGINT, 'bigint')).toBeFalse()))
+            // Boolean
+            .describe(`Boolean`, () => testing
+              .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isObjectKeyIn(TESTING_TRUE_INSTANCE, 'boolean')).toBeFalse())
+              .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isObjectKeyIn(TESTING_FALSE_INSTANCE, 'boolean')).toBeFalse())
+            )
+            // Number
+            .describe(`Number`, () =>
+              testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isObjectKeyIn(TESTING_NUMBER_INSTANCE, 'number')).toBeFalse()))
+            // String
+            .describe(`String`, () =>
+              testing.it(`new String(${TESTING_STRING})`, () => expect(isObjectKeyIn(TESTING_STRING_INSTANCE, 'string')).toBeFalse()))
+          )
+        );
     });
-  });
 });
diff --git a/src/is/test/is-object-key.spec.ts b/src/is/test/is-object-key.spec.ts
index 6e0a4fac..ce271816 100644
--- a/src/is/test/is-object-key.spec.ts
+++ b/src/is/test/is-object-key.spec.ts
@@ -1,143 +1,166 @@
 // Function.
 import { isObjectKey } from '../lib/is-object-key.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, TRUE_INSTANCE, FALSE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/strict/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(isObjectKey.name , () => {
-  // Defined.
-  it('is DEFINED', () => expect(isObjectKey).toBeDefined());
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isObjectKey(CLASS, ['firstName', 'surname'], (result: boolean, value: Class) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(CLASS);
-        return result;
-      });
-    });
-    // ... instance.
-    describe(`instance`, () => {
-      describe(`CLASS`, () => {
-        // number.
-        it('has number key', () => {
-          expect(isObjectKey(CLASS, 1030405027)).toBe(TRUE);
-          expect(isObjectKey(CLASS, 5)).toBe(TRUE);
-          expect(isObjectKey(CLASS, [5, 1030405027])).toBe(TRUE);
-        });
-        // It doesn't find getter number
-        it('has not find getter number', () => expect(isObjectKey(CLASS, NUMBER)).toBe(FALSE));
-        // string.
-        it('has string key', () => {
-          expect(isObjectKey(CLASS, 'surname')).toBe(TRUE);
-          expect(isObjectKey(CLASS, ['firstName', 'surname'])).toBe(TRUE);
-        });
-        // symbol.
-        it('has not find getter symbol key', () => {
-          // It does not find getter symbol key in class
-          expect(isObjectKey(CLASS, SYMBOL_NUMBER)).toBe(FALSE);
-          expect(isObjectKey(CLASS, SYMBOL_STRING)).toBe(FALSE);
-          expect(isObjectKey(CLASS, [SYMBOL_NUMBER, SYMBOL_STRING])).toBe(FALSE);
-        });
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.objectKey.describe,
+  tests.is.objectKey.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isObjectKey.name , () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isObjectKey).toBeDefined())
 
-        // mixed.
-        it('has string and number key', () => expect(isObjectKey(CLASS, [1030405027, 'firstName', 'surname'])).toBe(TRUE));
-      });
-    });
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isObjectKey(FUNCTION, 'function')).toBe(FALSE));
-      it(`CLASS`, () => expect(isObjectKey(Class, 'function')).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      describe(`OBJECT_ONE`, () => {
-        // number.
-        it('has number key', () => {
-          expect(isObjectKey(OBJECT_ONE, 1030405027)).toBe(TRUE);
-          expect(isObjectKey(OBJECT_ONE, 5)).toBe(TRUE);
-          expect(isObjectKey(OBJECT_ONE, NUMBER)).toBe(TRUE); // It doesn't find getter
-          expect(isObjectKey(OBJECT_ONE, [5, 1030405027])).toBe(TRUE);
-        });
-        // string.
-        it('has string key', () => {
-          expect(isObjectKey(OBJECT_ONE, 'key as string')).toBe(TRUE);
-          expect(isObjectKey(OBJECT_ONE, 'x')).toBe(TRUE);
-          expect(isObjectKey(OBJECT_ONE, STRING)).toBe(TRUE);
-          expect(isObjectKey(OBJECT_ONE, ['key as string', 'x', STRING])).toBe(TRUE);
-        });
-        // symbol.
-        it('has symbol key', () => {
-          expect(isObjectKey(OBJECT_ONE, SYMBOL_NUMBER)).toBe(TRUE);
-          expect(isObjectKey(OBJECT_ONE, SYMBOL_STRING)).toBe(TRUE);
-          expect(isObjectKey(OBJECT_ONE, [SYMBOL_NUMBER, SYMBOL_STRING])).toBe(TRUE);
-        });
-        // mixed.
-        it('has mixed key', () => {
-          expect(isObjectKey(OBJECT_ONE, [
-            'key as string',
-            'x',
-            1030405027,
-            5,
-            NUMBER,
-            STRING,
-            SYMBOL_NUMBER,
-            SYMBOL_STRING,
-          ])).toBe(TRUE);
-        });
-      });
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isObjectKey(BIGINT, 'bigint')).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isObjectKey(TRUE, 'boolean')).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isObjectKey(FALSE, 'boolean')).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isObjectKey(NULL, 'null')).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isObjectKey(NUMBER, 'number')).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isObjectKey(NUMBER_INSTANCE, 'number')).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isObjectKey(STRING, 'string')).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isObjectKey(STRING_INSTANCE, 'string')).toBe(FALSE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isObjectKey(SYMBOL_NUMBER, 'symbol')).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isObjectKey(SYMBOL_STRING, 'symbol')).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isObjectKey(UNDEFINED, 'undefined')).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isObjectKey(BIGINT_INSTANCE, 'bigint')).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isObjectKey(TRUE_INSTANCE, 'boolean')).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isObjectKey(FALSE_INSTANCE, 'boolean')).toBe(FALSE));
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isObjectKey(TESTING_CLASS, 'firstName', (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_CLASS);
+              expect(payload.key).toEqual('firstName');
+            }
+            return result;
+          });
+        })
+        // ... instance.
+        .describe(`instance`, () => {
+          testing
+            .describe(`TESTING_CLASS`, () => {
+              testing
+                // number.
+                .it('has number key', () => {
+                  expect(isObjectKey(TESTING_CLASS, 1030405027)).toBeTrue();
+                  expect(isObjectKey(TESTING_CLASS, 5)).toBeTrue();
+                })
+                // It doesn't find getter number
+                .it('has not find getter number', () => expect(isObjectKey(TESTING_CLASS, TESTING_NUMBER)).toBeFalse())
+                // string.
+                .it('has string key', () => {
+                  expect(isObjectKey(TESTING_CLASS, 'surname')).toBeTrue();
+                })
+                // symbol.
+                .it('has not find getter symbol key', () => {
+                  // It does not find getter symbol key in class
+                  expect(isObjectKey(TESTING_CLASS, TESTING_SYMBOL_NUMBER)).toBeFalse();
+                  expect(isObjectKey(TESTING_CLASS, TESTING_SYMBOL_STRING)).toBeFalse();
+                });
+            });
+        })
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isObjectKey(TESTING_FUNCTION, 'function')).toBeFalse())
+            .it(`TESTING_CLASS`, () => expect(isObjectKey(TestingClass, 'function')).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .describe(`TESTING_OBJECT`, () => {
+              testing
+                // number.
+                .it('has number key', () => {
+                  expect(isObjectKey(TESTING_OBJECT, 1030405027)).toBeTrue();
+                  expect(isObjectKey(TESTING_OBJECT, 5)).toBeTrue();
+                  expect(isObjectKey(TESTING_OBJECT, TESTING_NUMBER)).toBeTrue(); // It doesn't find getter
+                })
+                // string.
+                .it('has string key', () => {
+                  expect(isObjectKey(TESTING_OBJECT, 'key as string')).toBeTrue();
+                  expect(isObjectKey(TESTING_OBJECT, 'x')).toBeTrue();
+                  expect(isObjectKey(TESTING_OBJECT, TESTING_STRING)).toBeTrue();
+                })
+                // symbol.
+                .it('has symbol key', () => {
+                  expect(isObjectKey(TESTING_OBJECT, TESTING_SYMBOL_NUMBER)).toBeTrue();
+                  expect(isObjectKey(TESTING_OBJECT, TESTING_SYMBOL_STRING)).toBeTrue();
+                });
+            });
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => it(`${TESTING_BIGINT}`, () => expect(isObjectKey(TESTING_BIGINT, 'bigint')).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isObjectKey(TESTING_TRUE, 'boolean')).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isObjectKey(TESTING_FALSE, 'boolean')).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isObjectKey(TESTING_NULL, 'null')).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isObjectKey(TESTING_NUMBER, 'number')).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isObjectKey(TESTING_NUMBER_INSTANCE, 'number')).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isObjectKey(TESTING_STRING, 'string')).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isObjectKey(TESTING_STRING_INSTANCE, 'string')).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isObjectKey(TESTING_SYMBOL_NUMBER, 'symbol')).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isObjectKey(TESTING_SYMBOL_STRING, 'symbol')).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isObjectKey(TESTING_UNDEFINED, 'undefined')).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () =>
+                  testing.it(`${TESTING_BIGINT}`, () => expect(isObjectKey(TESTING_BIGINT, 'bigint')).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isObjectKey(TESTING_TRUE_INSTANCE, 'boolean')).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isObjectKey(TESTING_FALSE_INSTANCE, 'boolean')).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isObjectKey(TESTING_NUMBER_INSTANCE, 'number')).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isObjectKey(TESTING_STRING_INSTANCE, 'string')).toBeFalse()));
+            });
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isObjectKey(NUMBER_NEW_INSTANCE, 'number')).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isObjectKey(STRING_NEW_INSTANCE, 'string')).toBe(FALSE)));
-      });
     });
-  });
 });
diff --git a/src/is/test/is-object-keys-in.spec.ts b/src/is/test/is-object-keys-in.spec.ts
new file mode 100644
index 00000000..aea4a146
--- /dev/null
+++ b/src/is/test/is-object-keys-in.spec.ts
@@ -0,0 +1,173 @@
+// Function.
+import { isObjectKeysIn } from '../lib/is-object-keys-in.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.objectKeysIn.describe,
+  tests.is.objectKeysIn.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isObjectKeysIn.name , () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isObjectKeysIn).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isObjectKeysIn(TESTING_CLASS, ['firstName', 'surname'], (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_CLASS);
+            }
+            return result;
+          });
+        })
+        // ... instance.
+        .describe(`instance`, () => testing
+          .describe(`TESTING_CLASS`, () => testing
+            // number.
+            .it('has number key', () => {
+              expect(isObjectKeysIn(TESTING_CLASS, [1030405027])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_CLASS, [5])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_CLASS, [TESTING_NUMBER])).toBeTrue(); // It does find getter number
+              expect(isObjectKeysIn(TESTING_CLASS, [5, 1030405027])).toBeTrue();
+            })
+            // string.
+            .it('has string key', () => {
+              expect(isObjectKeysIn(TESTING_CLASS, ['surname'])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_CLASS, ['firstName', 'surname'])).toBeTrue();
+            })
+            // symbol.
+            .it('has getter symbol key', () => {
+              // It does find getter symbol key
+              expect(isObjectKeysIn(TESTING_CLASS, [TESTING_SYMBOL_NUMBER])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_CLASS, [TESTING_SYMBOL_STRING])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_CLASS, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeTrue();
+            })
+            // mixed.
+            .it('has string and number key', () => expect(isObjectKeysIn(TESTING_CLASS, [1030405027, 'firstName', 'surname'])).toBeTrue())
+          )
+        )
+        // ... function.
+        .describe(`function`, () => testing
+          .it(`TESTING_FUNCTION`, () => expect(isObjectKeysIn(TESTING_FUNCTION, ['function'])).toBeFalse())
+          .it(`TESTING_CLASS`, () => expect(isObjectKeysIn(TestingClass, ['function'])).toBeFalse())
+        )
+        // ... objects.
+        .describe('object', () => testing
+          .describe(`TESTING_OBJECT`, () => testing
+            // number.
+            .it('has number key', () => {
+              expect(isObjectKeysIn(TESTING_OBJECT, [1030405027])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_OBJECT, [5])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_OBJECT, [TESTING_NUMBER])).toBeTrue(); // It doesn't find getter
+              expect(isObjectKeysIn(TESTING_OBJECT, [5, 1030405027])).toBeTrue();
+            })
+            // string.
+            .it('has string key', () => {
+              expect(isObjectKeysIn(TESTING_OBJECT, ['key as string'])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_OBJECT, ['x'])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_OBJECT, [TESTING_STRING])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_OBJECT, ['key as string', 'x', TESTING_STRING])).toBeTrue();
+            })
+            // symbol.
+            .it('has symbol key', () => {
+              expect(isObjectKeysIn(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_OBJECT, [TESTING_SYMBOL_STRING])).toBeTrue();
+              expect(isObjectKeysIn(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeTrue();
+            })
+            // mixed.
+            .it('has mixed key', () => {
+              expect(isObjectKeysIn(TESTING_OBJECT, [
+                'key as string',
+                'x',
+                1030405027,
+                5,
+                TESTING_NUMBER,
+                TESTING_STRING,
+                TESTING_SYMBOL_NUMBER,
+                TESTING_SYMBOL_STRING,
+              ])).toBeTrue();
+            })
+          )
+        )
+        // ... primitives.
+        .describe(`primitive`, () => testing
+          // bigint
+          .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isObjectKeysIn(TESTING_BIGINT, ['bigint'])).toBeFalse()))
+          // boolean
+          .describe(`boolean`, () => testing
+            .it(`${TESTING_TRUE}`, () => expect(isObjectKeysIn(TESTING_TRUE, ['boolean'])).toBeFalse())
+            .it(`${TESTING_FALSE}`, () => expect(isObjectKeysIn(TESTING_FALSE, ['boolean'])).toBeFalse())
+          )
+          // null
+          .it(`${TESTING_NULL}`, () => expect(isObjectKeysIn(TESTING_NULL, ['null'])).toBeFalse())
+          // number
+          .describe(`number`, () => testing
+            .it(`${TESTING_NUMBER}`, () => expect(isObjectKeysIn(TESTING_NUMBER, ['number'])).toBeFalse())
+            .it(`Number(${TESTING_NUMBER})`, () => expect(isObjectKeysIn(TESTING_NUMBER_INSTANCE, ['number'])).toBeFalse())
+          )
+          // string
+          .describe(`string`, () => testing
+            .it(`${TESTING_STRING}`, () => expect(isObjectKeysIn(TESTING_STRING, ['string'])).toBeFalse())
+            .it(`String(${TESTING_STRING})`, () => expect(isObjectKeysIn(TESTING_STRING_INSTANCE, ['string'])).toBeFalse())
+          )
+          // symbol
+          .describe(`symbol`, () => testing
+            .it(`Symbol(${TESTING_NUMBER})`, () => expect(isObjectKeysIn(TESTING_SYMBOL_NUMBER, ['symbol'])).toBeFalse())
+            .it(`Symbol(${TESTING_STRING})`, () => expect(isObjectKeysIn(TESTING_SYMBOL_STRING, ['symbol'])).toBeFalse())
+          )
+          // undefined
+          .it(`${TESTING_UNDEFINED}`, () => expect(isObjectKeysIn(TESTING_UNDEFINED, ['undefined'])).toBeFalse())
+          // ... object.
+          .describe(`object`, () => testing
+            // BigInt
+            .describe(`BigInt`, () =>
+              testing.it(`${TESTING_BIGINT}`, () => expect(isObjectKeysIn(TESTING_BIGINT, ['bigint'])).toBeFalse()))
+            // Boolean
+            .describe(`Boolean`, () => testing
+              .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isObjectKeysIn(TESTING_TRUE_INSTANCE, ['boolean'])).toBeFalse())
+              .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isObjectKeysIn(TESTING_FALSE_INSTANCE, ['boolean'])).toBeFalse())
+            )
+            // Number
+            .describe(`Number`, () =>
+              testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isObjectKeysIn(TESTING_NUMBER_INSTANCE, ['number'])).toBeFalse()))
+            // String
+            .describe(`String`, () =>
+              testing.it(`new String(${TESTING_STRING})`, () => expect(isObjectKeysIn(TESTING_STRING_INSTANCE, ['string'])).toBeFalse()))
+          )
+        );
+    });
+});
diff --git a/src/is/test/is-object-keys.spec.ts b/src/is/test/is-object-keys.spec.ts
index ff57b7ff..ff1bbfab 100644
--- a/src/is/test/is-object-keys.spec.ts
+++ b/src/is/test/is-object-keys.spec.ts
@@ -1,178 +1,172 @@
 // Function.
 import { isObjectKeys } from '../lib/is-object-keys.func';
-// Constant.
-import { ACCESSOR_DESCRIPTOR, DATA_DESCRIPTOR, OBJECT_ONE } from '../../testing/src/object.const';
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, TRUE_INSTANCE, FALSE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/strict/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(isObjectKeys.name , () => {
-  // Defined.
-  it('is DEFINED', () => expect(isObjectKeys).toBeDefined());
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
-  // Checks ...
-  describe(`checks`, () => {
-    // ... instance.
-    describe(`instance`, () => {
-      describe(`CLASS`, () => {
-        // number.
-        it('has number key', () => {
-          expect(isObjectKeys(CLASS, 1030405027)).toBe(TRUE);
-          expect(isObjectKeys(CLASS, 5)).toBe(TRUE);
-          expect(isObjectKeys(CLASS, [5, 1030405027])).toBe(TRUE);
-        });
-        // It doesn't find getter number
-        it('has not find getter number', () => expect(isObjectKeys(CLASS, NUMBER)).toBe(FALSE));
-        // string.
-        it('has string key', () => {
-          expect(isObjectKeys(CLASS, 'surname')).toBe(TRUE);
-          expect(isObjectKeys(CLASS, ['firstName', 'surname'])).toBe(TRUE);
-        });
-        // symbol.
-        it('has not find getter symbol key', () => {
-          // It does not find getter symbol key in class
-          expect(isObjectKeys(CLASS, SYMBOL_NUMBER)).toBe(FALSE);
-          expect(isObjectKeys(CLASS, SYMBOL_STRING)).toBe(FALSE);
-          expect(isObjectKeys(CLASS, [SYMBOL_NUMBER, SYMBOL_STRING])).toBe(FALSE);
-        });
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.objectKeys.describe,
+  tests.is.objectKeys.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isObjectKeys.name , () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isObjectKeys).toBeDefined())
 
-        // mixed.
-        it('has string and number key', () => expect(isObjectKeys(CLASS, [1030405027, 'firstName', 'surname'])).toBe(TRUE));
-      });
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        // ... instance.
+        .describe(`instance`, () => testing
+          .describe(`TESTING_CLASS`, () => testing
+            // number.
+            .it('has number key', () => {
+              expect(isObjectKeys(TESTING_CLASS, [1030405027])).toBeTrue();
+              expect(isObjectKeys(TESTING_CLASS, [5])).toBeTrue();
+              expect(isObjectKeys(TESTING_CLASS, [5, 1030405027])).toBeTrue();
+            })
+            // It doesn't find getter number
+            .it('has not find getter number', () => expect(isObjectKeys(TESTING_CLASS, [TESTING_NUMBER])).toBeFalse())
+            // string.
+            .it('has string key', () => {
+              expect(isObjectKeys(TESTING_CLASS, ['surname'])).toBeTrue();
+              expect(isObjectKeys(TESTING_CLASS, ['firstName', 'surname'])).toBeTrue();
+            })
+            // symbol.
+            .it('has not find getter symbol key', () => {
+              // It does not find getter symbol key in class
+              expect(isObjectKeys(TESTING_CLASS, [TESTING_SYMBOL_NUMBER])).toBeFalse();
+              expect(isObjectKeys(TESTING_CLASS, [TESTING_SYMBOL_STRING])).toBeFalse();
+              expect(isObjectKeys(TESTING_CLASS, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeFalse();
+            })
+            // mixed.
+            .it('has string and number key', () => expect(isObjectKeys(TESTING_CLASS, [1030405027, 'firstName', 'surname'])).toBeTrue())
+          )
+        )
+        // ... function.
+        .describe(`function`, () => testing
+          .it(`TESTING_FUNCTION`, () => expect(isObjectKeys(TESTING_FUNCTION, ['function'])).toBeFalse())
+          .it(`TESTING_CLASS`, () => expect(isObjectKeys(TestingClass, ['function'])).toBeFalse())
+        )
+        // ... objects.
+        .describe('object', () => {
+          describe(`TESTING_OBJECT`, () => testing
+            // number.
+            .it('has number key', () => {
+              expect(isObjectKeys(TESTING_OBJECT, [1030405027])).toBeTrue();
+              expect(isObjectKeys(TESTING_OBJECT, [5])).toBeTrue();
+              expect(isObjectKeys(TESTING_OBJECT, [TESTING_NUMBER])).toBeTrue(); // It doesn't find getter
+              expect(isObjectKeys(TESTING_OBJECT, [5, 1030405027])).toBeTrue();
+            })
+            // string.
+            .it('has string key', () => {
+              expect(isObjectKeys(TESTING_OBJECT, ['key as string'])).toBeTrue();
+              expect(isObjectKeys(TESTING_OBJECT, ['x'])).toBeTrue();
+              expect(isObjectKeys(TESTING_OBJECT, [TESTING_STRING])).toBeTrue();
+              expect(isObjectKeys(TESTING_OBJECT, ['key as string', 'x', TESTING_STRING])).toBeTrue();
+            })
+            // symbol.
+            .it('has symbol key', () => {
+              expect(isObjectKeys(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER])).toBeTrue();
+              expect(isObjectKeys(TESTING_OBJECT, [TESTING_SYMBOL_STRING])).toBeTrue();
+              expect(isObjectKeys(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeTrue();
+            })
+            // mixed.
+            .it('has mixed key', () => {
+              expect(isObjectKeys(TESTING_OBJECT, [
+                'key as string',
+                'x',
+                1030405027,
+                5,
+                TESTING_NUMBER,
+                TESTING_STRING,
+                TESTING_SYMBOL_NUMBER,
+                TESTING_SYMBOL_STRING,
+              ])).toBeTrue();
+              // TRUE, TRUE
+              expect(isObjectKeys(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeTrue();
+              // TRUE AND FALSE
+              expect(isObjectKeys(TESTING_OBJECT, [TESTING_STRING, 'no property'])).toBeFalse();
+              // FALSE AND FALSE
+              expect(isObjectKeys(TESTING_OBJECT, ['no property one', 'no property two'])).toBeFalse();
+            })
+          );
+        })
+        // ... primitives.
+        .describe(`primitive`, () => testing
+          // bigint
+          .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isObjectKeys(TESTING_BIGINT, ['bigint'])).toBeFalse()))
+          // boolean
+          .describe(`boolean`, () => testing
+            .it(`${TESTING_TRUE}`, () => expect(isObjectKeys(TESTING_TRUE, ['boolean'])).toBeFalse())
+            .it(`${TESTING_FALSE}`, () => expect(isObjectKeys(TESTING_FALSE, ['boolean'])).toBeFalse())
+          )
+          // null
+          .it(`${TESTING_NULL}`, () => expect(isObjectKeys(TESTING_NULL, ['null'])).toBeFalse())
+          // number
+          .describe(`number`, () => testing
+            .it(`${TESTING_NUMBER}`, () => expect(isObjectKeys(TESTING_NUMBER, ['number'])).toBeFalse())
+            .it(`Number(${TESTING_NUMBER})`, () => expect(isObjectKeys(TESTING_NUMBER_INSTANCE, ['number'])).toBeFalse())
+          )
+          // string
+          .describe(`string`, () => testing
+            .it(`${TESTING_STRING}`, () => expect(isObjectKeys(TESTING_STRING, ['string'])).toBeFalse())
+            .it(`String(${TESTING_STRING})`, () => expect(isObjectKeys(TESTING_STRING_INSTANCE, ['string'])).toBeFalse())
+          )
+          // symbol
+          .describe(`symbol`, () => testing
+            .it(`Symbol(${TESTING_NUMBER})`, () => expect(isObjectKeys(TESTING_SYMBOL_NUMBER, ['symbol'])).toBeFalse())
+            .it(`Symbol(${TESTING_STRING})`, () => expect(isObjectKeys(TESTING_SYMBOL_STRING, ['symbol'])).toBeFalse())
+          )
+          // undefined
+          .it(`${TESTING_UNDEFINED}`, () => expect(isObjectKeys(TESTING_UNDEFINED, ['undefined'])).toBeFalse())
+          // ... object.
+          .describe(`object`, () => testing
+            // BigInt
+            .describe(`BigInt`, () =>
+              testing.it(`${TESTING_BIGINT}`, () => expect(isObjectKeys(TESTING_BIGINT, ['bigint'])).toBeFalse()))
+            // Boolean
+            .describe(`Boolean`, () => testing
+              .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isObjectKeys(TESTING_TRUE_INSTANCE, ['boolean'])).toBeFalse())
+              .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isObjectKeys(TESTING_FALSE_INSTANCE, ['boolean'])).toBeFalse())
+            )
+            // Number
+            .describe(`Number`, () =>
+              testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isObjectKeys(TESTING_NUMBER_INSTANCE, ['number'])).toBeFalse()))
+            // String
+            .describe(`String`, () =>
+              testing.it(`new String(${TESTING_STRING})`, () => expect(isObjectKeys(TESTING_STRING_INSTANCE, ['string'])).toBeFalse()))
+          )
+        );
     });
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isObjectKeys(FUNCTION, 'function')).toBe(FALSE));
-      it(`CLASS`, () => expect(isObjectKeys(Class, 'function')).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      describe(`descriptor`, () => {
-        it(`DATA_DESCRIPTOR`, () => {
-          expect(isObjectKeys(DATA_DESCRIPTOR, ['writable', 'value'], ['get', 'set'])).toBe(TRUE);
-          expect(isObjectKeys(DATA_DESCRIPTOR, ['writable', 'value'])).toBe(TRUE);
-          expect(isObjectKeys(DATA_DESCRIPTOR, 'writable', 'value')).toBe(TRUE);
-          expect(isObjectKeys(DATA_DESCRIPTOR, ['get', 'set'])).toBe(FALSE);
-          expect(isObjectKeys(DATA_DESCRIPTOR, 'get', 'set')).toBe(FALSE);
-          expect(isObjectKeys(DATA_DESCRIPTOR, ['configurable', 'enumerable'], 'writable', 'value')).toBe(TRUE);
-          expect(isObjectKeys(DATA_DESCRIPTOR, ['configurable', 'enumerable'], 'value')).toBe(TRUE);
-          expect(isObjectKeys(DATA_DESCRIPTOR, ['configurable', 'enumerable'], 'writable')).toBe(TRUE);
-        });
-        it(`ACCESSOR_DESCRIPTOR`, () => {
-          expect(isObjectKeys(ACCESSOR_DESCRIPTOR, ['writable', 'value'], ['get', 'set'])).toBe(TRUE);
-          expect(isObjectKeys(ACCESSOR_DESCRIPTOR, ['configurable', 'enumerable'], 'writable', 'value')).toBe(TRUE);
-          expect(isObjectKeys(ACCESSOR_DESCRIPTOR, ['configurable', 'enumerable'], 'get')).toBe(TRUE);
-          expect(isObjectKeys(ACCESSOR_DESCRIPTOR, ['configurable', 'enumerable'], 'set')).toBe(TRUE);
-        });
-      });
-      describe(`OBJECT_ONE`, () => {
-        // number.
-        it('has number key', () => {
-          expect(isObjectKeys(OBJECT_ONE, 1030405027)).toBe(TRUE);
-          expect(isObjectKeys(OBJECT_ONE, 5)).toBe(TRUE);
-          expect(isObjectKeys(OBJECT_ONE, NUMBER)).toBe(TRUE); // It doesn't find getter
-          expect(isObjectKeys(OBJECT_ONE, [5, 1030405027])).toBe(TRUE);
-        });
-        // string.
-        it('has string key', () => {
-          expect(isObjectKeys(OBJECT_ONE, 'key as string')).toBe(TRUE);
-          expect(isObjectKeys(OBJECT_ONE, 'x')).toBe(TRUE);
-          expect(isObjectKeys(OBJECT_ONE, STRING)).toBe(TRUE);
-          expect(isObjectKeys(OBJECT_ONE, ['key as string', 'x', STRING])).toBe(TRUE);
-        });
-        // symbol.
-        it('has symbol key', () => {
-          expect(isObjectKeys(OBJECT_ONE, SYMBOL_NUMBER)).toBe(TRUE);
-          expect(isObjectKeys(OBJECT_ONE, SYMBOL_STRING)).toBe(TRUE);
-          expect(isObjectKeys(OBJECT_ONE, [SYMBOL_NUMBER, SYMBOL_STRING])).toBe(TRUE);
-        });
-        // mixed.
-        it('has mixed key', () => {
-          expect(isObjectKeys(OBJECT_ONE, [
-            'key as string',
-            'x',
-            1030405027,
-            5,
-            NUMBER,
-            STRING,
-            SYMBOL_NUMBER,
-            SYMBOL_STRING,
-          ])).toBe(TRUE);
-          // TRUE, TRUE
-          expect(isObjectKeys(OBJECT_ONE, SYMBOL_NUMBER, SYMBOL_STRING)).toBe(TRUE);
-          // [TRUE, TRUE] OR [TRUE, TRUE]
-          expect(isObjectKeys(OBJECT_ONE, [SYMBOL_NUMBER, STRING], [SYMBOL_STRING, NUMBER])).toBe(TRUE);
-          // TRUE OR FALSE
-          expect(isObjectKeys(OBJECT_ONE, STRING, 'no property')).toBe(TRUE);
-          // FALSE OR TRUE
-          expect(isObjectKeys(OBJECT_ONE, 'no property', NUMBER)).toBe(TRUE);
-          // [FALSE] OR [FALSE]
-          expect(isObjectKeys(OBJECT_ONE, ['no property'], ['no property'])).toBe(FALSE);
-          // FALSE OR FALSE
-          expect(isObjectKeys(OBJECT_ONE, 'no property one', 'no property two')).toBe(FALSE);
-          // [FALSE] OR FALSE
-          expect(isObjectKeys(OBJECT_ONE, ['no property one'], 'no property two')).toBe(FALSE);
-          // FALSE OR [FALSE]
-          expect(isObjectKeys(OBJECT_ONE, 'no property one', ['no property two'])).toBe(FALSE);
-          // FALSE OR [FALSE, TRUE]
-          expect(isObjectKeys(OBJECT_ONE, 'no property one', ['no property two', STRING])).toBe(FALSE);
-          // [FALSE, TRUE] OR FALSE
-          expect(isObjectKeys(OBJECT_ONE, ['no property one', STRING], 'no property two')).toBe(FALSE);
-          // TRUE OR [FALSE, TRUE]
-          expect(isObjectKeys(OBJECT_ONE, NUMBER, ['no property two', STRING])).toBe(TRUE);
-          // [FALSE, TRUE] OR TRUE
-          expect(isObjectKeys(OBJECT_ONE, ['no property one', STRING], NUMBER)).toBe(TRUE);
-        });
-      });
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isObjectKeys(BIGINT, 'bigint')).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isObjectKeys(TRUE, 'boolean')).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isObjectKeys(FALSE, 'boolean')).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isObjectKeys(NULL, 'null')).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isObjectKeys(NUMBER, 'number')).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isObjectKeys(NUMBER_INSTANCE, 'number')).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isObjectKeys(STRING, 'string')).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isObjectKeys(STRING_INSTANCE, 'string')).toBe(FALSE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isObjectKeys(SYMBOL_NUMBER, 'symbol')).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isObjectKeys(SYMBOL_STRING, 'symbol')).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isObjectKeys(UNDEFINED, 'undefined')).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isObjectKeys(BIGINT_INSTANCE, 'bigint')).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isObjectKeys(TRUE_INSTANCE, 'boolean')).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isObjectKeys(FALSE_INSTANCE, 'boolean')).toBe(FALSE));
-        });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isObjectKeys(NUMBER_NEW_INSTANCE, 'number')).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isObjectKeys(STRING_NEW_INSTANCE, 'string')).toBe(FALSE)));
-      });
-    });
-  });
 });
diff --git a/src/is/test/is-object-some-keys.spec.ts b/src/is/test/is-object-some-keys.spec.ts
new file mode 100644
index 00000000..0fa47035
--- /dev/null
+++ b/src/is/test/is-object-some-keys.spec.ts
@@ -0,0 +1,191 @@
+// Function.
+import { isObjectSomeKeys } from '../lib/is-object-some-keys.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.objectSomeKeys.describe,
+  tests.is.objectSomeKeys.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isObjectSomeKeys.name , () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isObjectSomeKeys).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        // ... instance.
+        .describe(`instance`, () => testing
+          .describe(`TESTING_CLASS`, () => testing
+            // number.
+            .it('has number key', () => {
+              expect(isObjectSomeKeys(TESTING_CLASS, [1030405027])).toBeTrue();
+              expect(isObjectSomeKeys(TESTING_CLASS, [5])).toBeTrue();
+              expect(isObjectSomeKeys(TESTING_CLASS, [5, 1030405027])).toBeTrue();
+            })
+            // It doesn't find getter number
+            .it('has not find getter number', () => expect(isObjectSomeKeys(TESTING_CLASS, [TESTING_NUMBER])).toBeFalse())
+            // string.
+            .it('has string key', () => {
+              expect(isObjectSomeKeys(TESTING_CLASS, ['surname'])).toBeTrue();
+              expect(isObjectSomeKeys(TESTING_CLASS, ['firstName', 'surname'])).toBeTrue();
+            })
+            // symbol.
+            .it('has not find getter symbol key', () => {
+              // It does not find getter symbol key in class
+              expect(isObjectSomeKeys(TESTING_CLASS, [TESTING_SYMBOL_NUMBER])).toBeFalse();
+              expect(isObjectSomeKeys(TESTING_CLASS, [TESTING_SYMBOL_STRING])).toBeFalse();
+              expect(isObjectSomeKeys(TESTING_CLASS, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeFalse();
+            })
+            // mixed.
+            .it('has string and number key', () => expect(isObjectSomeKeys(TESTING_CLASS, [1030405027, 'firstName', 'surname'])).toBeTrue())
+          )
+        )
+        // ... function.
+        .describe(`function`, () => testing
+          .it(`TESTING_FUNCTION`, () => expect(isObjectSomeKeys(TESTING_FUNCTION, ['function'])).toBeFalse())
+          .it(`TESTING_CLASS`, () => expect(isObjectSomeKeys(TestingClass, ['function'])).toBeFalse())
+        )
+        // ... objects.
+        .describe('object', () => {
+          describe(`TESTING_OBJECT`, () => testing
+            // number.
+            .it('has number key', () => {
+              expect(isObjectSomeKeys(TESTING_OBJECT, [1030405027])).toBeTrue();
+              expect(isObjectSomeKeys(TESTING_OBJECT, [5])).toBeTrue();
+              expect(isObjectSomeKeys(TESTING_OBJECT, [TESTING_NUMBER])).toBeTrue(); // It doesn't find getter
+              expect(isObjectSomeKeys(TESTING_OBJECT, [5, 1030405027])).toBeTrue();
+            })
+            // string.
+            .it('has string key', () => {
+              expect(isObjectSomeKeys(TESTING_OBJECT, ['key as string'])).toBeTrue();
+              expect(isObjectSomeKeys(TESTING_OBJECT, ['x'])).toBeTrue();
+              expect(isObjectSomeKeys(TESTING_OBJECT, [TESTING_STRING])).toBeTrue();
+              expect(isObjectSomeKeys(TESTING_OBJECT, ['key as string', 'x', TESTING_STRING])).toBeTrue();
+            })
+            // symbol.
+            .it('has symbol key', () => {
+              expect(isObjectSomeKeys(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER])).toBeTrue();
+              expect(isObjectSomeKeys(TESTING_OBJECT, [TESTING_SYMBOL_STRING])).toBeTrue();
+              expect(isObjectSomeKeys(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeTrue();
+            })
+            // mixed.
+            .it('has mixed key', () => {
+              expect(isObjectSomeKeys(TESTING_OBJECT, [
+                'key as string',
+                'x',
+                1030405027,
+                5,
+                TESTING_NUMBER,
+                TESTING_STRING,
+                TESTING_SYMBOL_NUMBER,
+                TESTING_SYMBOL_STRING,
+              ])).toBeTrue();
+              // TRUE, TRUE
+              expect(isObjectSomeKeys(TESTING_OBJECT, [TESTING_SYMBOL_NUMBER, TESTING_SYMBOL_STRING])).toBeTrue();
+              // [TRUE, TRUE] OR [TRUE, TRUE]
+              expect(isObjectSomeKeys(TESTING_OBJECT,
+                  [[TESTING_SYMBOL_NUMBER, TESTING_STRING], [TESTING_SYMBOL_STRING, TESTING_NUMBER]])).toBeTrue();
+              // TRUE OR FALSE
+              expect(isObjectSomeKeys(TESTING_OBJECT, [TESTING_STRING, 'no property'])).toBeTrue();
+              // FALSE OR TRUE
+              expect(isObjectSomeKeys(TESTING_OBJECT, ['no property', TESTING_NUMBER])).toBeTrue();
+              // [FALSE] OR [FALSE]
+              expect(isObjectSomeKeys(TESTING_OBJECT, [['no property'], ['no property']])).toBeFalse();
+              // FALSE OR FALSE
+              expect(isObjectSomeKeys(TESTING_OBJECT, ['no property one', 'no property two'])).toBeFalse();
+              // [FALSE] OR FALSE
+              expect(isObjectSomeKeys(TESTING_OBJECT, [['no property one'], 'no property two'])).toBeFalse();
+              // FALSE OR [FALSE]
+              expect(isObjectSomeKeys(TESTING_OBJECT, ['no property one', ['no property two']])).toBeFalse();
+              // FALSE OR [FALSE, TRUE]
+              expect(isObjectSomeKeys(TESTING_OBJECT, ['no property one', ['no property two', TESTING_STRING]])).toBeFalse();
+              // [FALSE, TRUE] OR FALSE
+              expect(isObjectSomeKeys(TESTING_OBJECT, [['no property one', TESTING_STRING], 'no property two'])).toBeFalse();
+              // TRUE OR [FALSE, TRUE]
+              expect(isObjectSomeKeys(TESTING_OBJECT, [TESTING_NUMBER, ['no property two', TESTING_STRING]])).toBeTrue();
+              // [FALSE, TRUE] OR TRUE
+              expect(isObjectSomeKeys(TESTING_OBJECT, [['no property one', TESTING_STRING], TESTING_NUMBER])).toBeTrue();
+            })
+          );
+        })
+        // ... primitives.
+        .describe(`primitive`, () => testing
+          // bigint
+          .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isObjectSomeKeys(TESTING_BIGINT, ['bigint'])).toBeFalse()))
+          // boolean
+          .describe(`boolean`, () => testing
+            .it(`${TESTING_TRUE}`, () => expect(isObjectSomeKeys(TESTING_TRUE, ['boolean'])).toBeFalse())
+            .it(`${TESTING_FALSE}`, () => expect(isObjectSomeKeys(TESTING_FALSE, ['boolean'])).toBeFalse())
+          )
+          // null
+          .it(`${TESTING_NULL}`, () => expect(isObjectSomeKeys(TESTING_NULL, ['null'])).toBeFalse())
+          // number
+          .describe(`number`, () => testing
+            .it(`${TESTING_NUMBER}`, () => expect(isObjectSomeKeys(TESTING_NUMBER, ['number'])).toBeFalse())
+            .it(`Number(${TESTING_NUMBER})`, () => expect(isObjectSomeKeys(TESTING_NUMBER_INSTANCE, ['number'])).toBeFalse())
+          )
+          // string
+          .describe(`string`, () => testing
+            .it(`${TESTING_STRING}`, () => expect(isObjectSomeKeys(TESTING_STRING, ['string'])).toBeFalse())
+            .it(`String(${TESTING_STRING})`, () => expect(isObjectSomeKeys(TESTING_STRING_INSTANCE, ['string'])).toBeFalse())
+          )
+          // symbol
+          .describe(`symbol`, () => testing
+            .it(`Symbol(${TESTING_NUMBER})`, () => expect(isObjectSomeKeys(TESTING_SYMBOL_NUMBER, ['symbol'])).toBeFalse())
+            .it(`Symbol(${TESTING_STRING})`, () => expect(isObjectSomeKeys(TESTING_SYMBOL_STRING, ['symbol'])).toBeFalse())
+          )
+          // undefined
+          .it(`${TESTING_UNDEFINED}`, () => expect(isObjectSomeKeys(TESTING_UNDEFINED, ['undefined'])).toBeFalse())
+          // ... object.
+          .describe(`object`, () => testing
+            // BigInt
+            .describe(`BigInt`, () =>
+              testing.it(`${TESTING_BIGINT}`, () => expect(isObjectSomeKeys(TESTING_BIGINT, ['bigint'])).toBeFalse()))
+            // Boolean
+            .describe(`Boolean`, () => testing
+              .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isObjectSomeKeys(TESTING_TRUE_INSTANCE, ['boolean'])).toBeFalse())
+              .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isObjectSomeKeys(TESTING_FALSE_INSTANCE, ['boolean'])).toBeFalse())
+            )
+            // Number
+            .describe(`Number`, () =>
+              testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isObjectSomeKeys(TESTING_NUMBER_INSTANCE, ['number'])).toBeFalse()))
+            // String
+            .describe(`String`, () =>
+              testing.it(`new String(${TESTING_STRING})`, () => expect(isObjectSomeKeys(TESTING_STRING_INSTANCE, ['string'])).toBeFalse()))
+          )
+        );
+    });
+});
diff --git a/src/is/test/is-object.spec.ts b/src/is/test/is-object.spec.ts
index a8bd06ab..a898d36d 100644
--- a/src/is/test/is-object.spec.ts
+++ b/src/is/test/is-object.spec.ts
@@ -1,95 +1,134 @@
 // Function.
 import { isObject } from '../lib/is-object.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.object.describe,
+  tests.is.object.it
+);
 /**
  * Checks
  * ✓ typeof === 'object'
  * ✓ instanceof Object
  */
-describe(isObject.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isObject).toBeDefined());
+testing.describe(isObject.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isObject).toBeDefined())
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isObject(OBJECT_ONE, (result: boolean, value: any) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(OBJECT_ONE);
-        return result;
-      });
-    });
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isObject(TESTING_OBJECT, (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_OBJECT);
+            }
+            return result;
+          });
+        })
 
-    // ... arrays.
-    describe(`array`, () => {});
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isObject(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isObject(Class)).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isObject(CLASS)).toBe(TRUE));
-      it(`OBJECT_ONE`, () => expect(isObject(OBJECT_ONE)).toBe(TRUE));
-      it(`OBJECT_TWO`, () => expect(isObject(OBJECT_TWO)).toBe(TRUE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isObject(OBJECT_ONE_NEW)).toBe(TRUE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isObject(OBJECT_TWO_NEW)).toBe(TRUE));
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isObject(BIGINT)).toBe(FALSE)));
+        // ... arrays.
+        .describe(`array`, () => {})
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isObject(TESTING_FUNCTION)).toBeFalse())
+            .it(`TestingClass`, () => expect(isObject(TestingClass)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isObject(TESTING_CLASS)).toBeTrue())
+            .it(`TESTING_OBJECT`, () => expect(isObject(TESTING_OBJECT)).toBeTrue())
+            .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isObject(TESTING_OBJECT)).toBeTrue())
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isObject(TESTING_BIGINT)).toBeFalse()))
 
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isObject(TRUE)).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isObject(FALSE)).toBe(FALSE));
-      });
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isObject(TESTING_TRUE)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isObject(TESTING_FALSE)).toBeFalse());
+            })
 
-      // null
-      it(`${NULL}`, () => expect(isObject(NULL)).toBe(FALSE));
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isObject(TESTING_NULL)).toBeFalse())
 
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isObject(NUMBER)).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isObject(NUMBER_INSTANCE)).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isObject(STRING)).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isObject(STRING_INSTANCE)).toBe(FALSE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isObject(SYMBOL_NUMBER)).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isObject(SYMBOL_STRING)).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isObject(UNDEFINED)).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isObject(BIGINT_INSTANCE)).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isObject(TRUE_INSTANCE)).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isObject(FALSE_INSTANCE)).toBe(FALSE));
-          });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isObject(NUMBER_NEW_INSTANCE)).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isObject(STRING_NEW_INSTANCE)).toBe(FALSE)));
-      });
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isObject(TESTING_NUMBER)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isObject(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isObject(TESTING_STRING)).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isObject(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isObject(TESTING_SYMBOL_NUMBER)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isObject(TESTING_SYMBOL_STRING)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isObject(TESTING_UNDEFINED)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isObject(TESTING_BIGINT)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isObject(TESTING_TRUE_INSTANCE)).toBeTrue())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isObject(TESTING_FALSE_INSTANCE)).toBeTrue());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isObject(TESTING_NUMBER_INSTANCE)).toBeTrue()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isObject(TESTING_STRING_INSTANCE)).toBeTrue()));
+            });
+        });
     });
-  });
 });
diff --git a/src/is/test/is-param.spec.ts b/src/is/test/is-param.spec.ts
index 88f6d0cc..a0022f37 100644
--- a/src/is/test/is-param.spec.ts
+++ b/src/is/test/is-param.spec.ts
@@ -1,6 +1,16 @@
-import { NUMBER } from '../../testing/src/number.const';
-import { STRING } from '../../testing/src/string.const';
+// Decorator.
 import { isParam } from '../lib/is-param.decorator';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_NUMBER,
+  TESTING_STRING,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
 
 class TestClass {
   @isParam('object', 'string', 'number')
@@ -8,71 +18,56 @@ class TestClass {
     return {object, firstName, age};
   }
 }
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.param.describe,
+  tests.is.param.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isParam.name, () => {
+  const resultTRUE = new TestClass().testMethod({firstName: 'NoName'}, TESTING_STRING, TESTING_NUMBER);
+  const resultFALSE = new TestClass().testMethod(TESTING_NUMBER, {firstName: 'NoName'}, TESTING_STRING);
 
-describe(isParam.name, () => {
-  const resultTRUE = new TestClass().testMethod({firstName: 'NoName'}, STRING, NUMBER);
-  const resultFALSE = new TestClass().testMethod(NUMBER, {firstName: 'NoName'}, STRING);
-
+  testing
   // Defined.
-  it('is DEFINED', () => expect(isParam).toBeDefined());
+  .it('is DEFINED', () => expect(isParam).toBeDefined())
 
   // Checks ...
-  describe(`checks`, () => {
+  .describe(`checks`, () => {
+    testing
     // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => {
+    .describe('object', () => {
+      testing
+      .it(`TESTING_CLASS`, () => {
         expect(resultTRUE.object).toEqual({firstName: 'NoName'});
         expect(resultFALSE.object).toBeUndefined();
       });
-    });
+    })
 
     // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      // describe(`bigint`, () => {
-      //   it(`${BIGINT}`, () => expect(isPrimitive(BIGINT, 'bigint')).toBe(TRUE));
-      //   it(`${BIGINT_EXPECTATION}`, () => expect(isPrimitive(BIGINT_INSTANCE, 'bigint')).toBe(TRUE));
-      // });
-
-      // boolean
-      // describe(`boolean`, () => {
-      //   it(`${TRUE}`, () => expect(isPrimitive(TRUE, 'boolean')).toBe(TRUE));
-      //   it(`${FALSE}`, () => expect(isPrimitive(FALSE, 'boolean')).toBe(TRUE));
-      //   it(`${FALSE_EXPECTATION}`, () => expect(isPrimitive(TRUE_INSTANCE, 'boolean')).toBe(TRUE));
-      //   it(`${TRUE_EXPECTATION}`, () => expect(isPrimitive(FALSE_INSTANCE, 'boolean')).toBe(TRUE));
-      // });
-
-      // null
-      // it(`${NULL}`, () => expect(isPrimitive(NULL, 'null')).toBe(TRUE));
-
+    .describe(`primitive`, () => {
+      testing
       // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => {
-          expect(resultTRUE.age).toBe(NUMBER);
+      .describe(`number`, () => {
+        testing
+        .it(`${TESTING_NUMBER}`, () => {
+          expect(resultTRUE.age).toBe(TESTING_NUMBER);
           expect(resultFALSE.age).toBeUndefined();
         });
-        // it(`Number(${NUMBER})`, () => expect(isPrimitive(NUMBER_INSTANCE, 'number')).toBe(TRUE));
-        // it(`new Number(${NUMBER})`, () => expect(isPrimitive(NUMBER_NEW_INSTANCE, 'number')).toBe(TRUE));
-      });
+      })
 
       // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => {
-          expect(resultTRUE.firstName).toBe(STRING);
+      .describe(`string`, () => {
+        testing
+        .it(`${TESTING_STRING}`, () => {
+          expect(resultTRUE.firstName).toBe(TESTING_STRING);
           expect(resultFALSE.firstName).toBeUndefined();
         });
-        // it(`String(${STRING})`, () => expect(isPrimitive(STRING_INSTANCE, 'string')).toBe(TRUE));
-        // it(`new String(${STRING})`, () => expect(isPrimitive(STRING_NEW_INSTANCE, 'string')).toBe(TRUE));
       });
-
-      // symbol
-      describe(`symbol`, () => {
-        // it(`Symbol(${NUMBER})`, () => expect(isPrimitive(SYMBOL_NUMBER, 'symbol')).toBe(TRUE));
-        // it(`Symbol(${STRING})`, () => expect(isPrimitive(SYMBOL_STRING, 'symbol')).toBe(TRUE));
-      });
-
-      // undefined
-      // it(`${UNDEFINED}`, () => expect(isPrimitive(UNDEFINED, 'undefined')).toBe(TRUE));
     });
   });
 });
diff --git a/src/is/test/is-primitive.spec.ts b/src/is/test/is-primitive.spec.ts
index 5e6bbfd5..802d2658 100644
--- a/src/is/test/is-primitive.spec.ts
+++ b/src/is/test/is-primitive.spec.ts
@@ -1,73 +1,111 @@
 // Function.
 import { isPrimitive } from '../lib/is-primitive.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { FALSE, TRUE, TRUE_INSTANCE, FALSE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(isPrimitive.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isPrimitive).toBeDefined());
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isPrimitive<string>(STRING, 'string' , (result: boolean, value: string) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(STRING);
-        return result;
-      });
-    });
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.primitive.describe,
+  tests.is.primitive.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isPrimitive.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isPrimitive).toBeDefined())
 
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isPrimitive(BIGINT, 'bigint')).toBe(TRUE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isPrimitive(TRUE, 'boolean')).toBe(TRUE));
-        it(`${FALSE}`, () => expect(isPrimitive(FALSE, 'boolean')).toBe(TRUE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isPrimitive(NULL, 'null')).toBe(TRUE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isPrimitive(NUMBER, 'number')).toBe(TRUE));
-        it(`Number(${NUMBER})`, () => expect(isPrimitive(NUMBER_INSTANCE, 'number')).toBe(TRUE));
-        ;
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isPrimitive(STRING, 'string')).toBe(TRUE));
-        it(`String(${STRING})`, () => expect(isPrimitive(STRING_INSTANCE, 'string')).toBe(TRUE));
-        ;
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isPrimitive(SYMBOL_NUMBER, 'symbol')).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(isPrimitive(SYMBOL_STRING, 'symbol')).toBe(TRUE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isPrimitive(UNDEFINED, 'undefined')).toBe(TRUE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isPrimitive(BIGINT_INSTANCE, 'bigint')).toBe(TRUE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isPrimitive(TRUE_INSTANCE, 'boolean')).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isPrimitive(FALSE_INSTANCE, 'boolean')).toBe(FALSE));
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isPrimitive<string>(TESTING_STRING, 'string' , (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_STRING);
+            }
+            return result;
           });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isPrimitive(NUMBER_NEW_INSTANCE, 'number')).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isPrimitive(STRING_NEW_INSTANCE, 'string')).toBe(FALSE)));
-      });
+        })
+
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isPrimitive(TESTING_BIGINT, 'bigint')).toBeTrue()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isPrimitive(TESTING_TRUE, 'boolean')).toBeTrue())
+                .it(`${TESTING_FALSE}`, () => expect(isPrimitive(TESTING_FALSE, 'boolean')).toBeTrue());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isPrimitive(TESTING_NULL, 'null')).toBeTrue())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isPrimitive(TESTING_NUMBER, 'number')).toBeTrue())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isPrimitive(TESTING_NUMBER_CONSTRUCTOR, 'number')).toBeTrue());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isPrimitive(TESTING_STRING, 'string')).toBeTrue())
+                .it(`String(${TESTING_STRING})`, () => expect(isPrimitive(TESTING_STRING_CONSTRUCTOR, 'string')).toBeTrue());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isPrimitive(TESTING_SYMBOL_NUMBER, 'symbol')).toBeTrue())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isPrimitive(TESTING_SYMBOL_STRING, 'symbol')).toBeTrue());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isPrimitive(TESTING_UNDEFINED, 'undefined')).toBeTrue())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () =>
+                  testing.it(`${TESTING_BIGINT}`, () => expect(isPrimitive(TESTING_BIGINT, 'bigint')).toBeTrue()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isPrimitive(TESTING_TRUE_INSTANCE, 'boolean')).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isPrimitive(TESTING_FALSE_INSTANCE, 'boolean')).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isPrimitive(TESTING_NUMBER_INSTANCE, 'number')).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isPrimitive(TESTING_STRING_INSTANCE, 'string')).toBeFalse()));
+            });
 
+        });
     });
-  });
 });
diff --git a/src/is/test/is-regexp.spec.ts b/src/is/test/is-regexp.spec.ts
new file mode 100644
index 00000000..128beee3
--- /dev/null
+++ b/src/is/test/is-regexp.spec.ts
@@ -0,0 +1,133 @@
+// Function.
+import { isRegExp } from '../lib/is-regexp.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_DATE,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_REGEXP,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.regexp.describe,
+  tests.is.regexp.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isRegExp.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isRegExp).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing.
+        it('callback', () => {
+          isRegExp(TESTING_REGEXP, (result: boolean) => {
+            expect(result).toBeTrue();
+            return result;
+          });
+        })
+        // ... arrays.
+        .describe(`array`, () => {})
+        // ... Date.
+        .describe(`date`, () => {
+          testing
+            .it(`TESTING_DATE`, () => expect(isRegExp(TESTING_DATE)).toBeFalse())
+        })
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isRegExp(TESTING_FUNCTION)).toBeFalse())
+            .it(`TestingClass`, () => expect(isRegExp(TestingClass)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isRegExp(TESTING_CLASS)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isRegExp(TESTING_OBJECT)).toBeFalse())
+            .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isRegExp(TESTING_OBJECT)).toBeFalse())
+            .it(`TESTING_REGEXP ${TESTING_REGEXP}`, () => expect(isRegExp(TESTING_REGEXP)).toBeTrue());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isRegExp(TESTING_BIGINT)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isRegExp(TESTING_TRUE)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isRegExp(TESTING_FALSE)).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isRegExp(TESTING_NULL)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isRegExp(TESTING_NUMBER)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isRegExp(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isRegExp(TESTING_STRING)).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isRegExp(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isRegExp(TESTING_SYMBOL_NUMBER)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isRegExp(TESTING_SYMBOL_STRING)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isRegExp(TESTING_UNDEFINED)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isRegExp(TESTING_BIGINT)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isRegExp(TESTING_TRUE_INSTANCE)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isRegExp(TESTING_FALSE_INSTANCE)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isRegExp(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isRegExp(TESTING_STRING_INSTANCE)).toBeFalse()));
+            });
+        });
+    });
+});
diff --git a/src/is/test/is-string-includes-some.spec.ts b/src/is/test/is-string-includes-some.spec.ts
new file mode 100644
index 00000000..147e9e18
--- /dev/null
+++ b/src/is/test/is-string-includes-some.spec.ts
@@ -0,0 +1,190 @@
+// Function.
+import { isStringIncludesSome } from '../lib/is-string-includes-some.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.stringIncludesSome.describe,
+  tests.is.stringIncludesSome.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isStringIncludesSome.name, () => {
+  const TESTING_STRING_LONG = `Lorem Ipsum is simply dummy text of the printing and typesetting industry.
+  Lorem Ipsum has been the industry's standard dummy text ever since the 1500s,
+  when an unknown printer took a galley of type and scrambled it to make a type specimen book.
+  It has survived not only five centuries, but also the leap into electronic typesetting,
+  remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset
+  sheets containing Lorem Ipsum passages, and more recently with desktop publishing software
+  like Aldus PageMaker including versions of Lorem Ipsum.`;
+
+  const TESTING_STRING_LONG_INSTANCE = new String(TESTING_STRING_LONG);
+
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isStringIncludesSome).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isStringIncludesSome(TESTING_STRING, ['Company'], (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_STRING);
+            }
+            return result;
+          });
+        })
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isStringIncludesSome(TESTING_FUNCTION, ['1', '2', '3'])).toBeFalse())
+            .it(`TestingClass`, () => expect(isStringIncludesSome(TestingClass, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isStringIncludesSome(TESTING_CLASS, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isStringIncludesSome(TESTING_OBJECT, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () =>
+              testing.it(`${TESTING_BIGINT}`, () =>
+                  expect(isStringIncludesSome(TESTING_BIGINT, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isStringIncludesSome(TESTING_TRUE, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isStringIncludesSome(TESTING_FALSE, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isStringIncludesSome(TESTING_NULL, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () =>
+                  expect(isStringIncludesSome(TESTING_NUMBER, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () =>
+                  expect(isStringIncludesSome(TESTING_NUMBER_INSTANCE, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`TESTING_STRING, TESTING_STRING_LONG`, () => {
+                  expect(isStringIncludesSome(TESTING_STRING, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeTrue();
+                    // No word exists.
+                  expect(isStringIncludesSome(TESTING_STRING_LONG, [
+                    'no text',
+                    'no text is here'
+                  ])).toBeFalse();
+
+                  // Every word exists.
+                  expect(isStringIncludesSome(TESTING_STRING_LONG, [
+                    'Lorem',
+                    'unchanged',
+                    'versions',
+                    'only',
+                  ])).toBeTrue();
+
+                  // Some word exists.
+                  expect(isStringIncludesSome(TESTING_STRING_LONG, [
+                    'Lorem',
+                    'unchanged',
+                    'versions',
+                    'only',
+                    'no text is here'
+                  ])).toBeTrue();
+                })
+                .it(`String(${TESTING_STRING})`, () =>
+                  expect(isStringIncludesSome(TESTING_STRING_CONSTRUCTOR, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeTrue());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isStringIncludesSome(TESTING_SYMBOL_NUMBER, [])).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isStringIncludesSome(TESTING_SYMBOL_STRING, [])).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () =>
+              expect(isStringIncludesSome(TESTING_UNDEFINED, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () =>
+                      expect(isStringIncludesSome(TESTING_TRUE_INSTANCE, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () =>
+                      expect(isStringIncludesSome(TESTING_FALSE_INSTANCE, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () =>
+                    expect(isStringIncludesSome(TESTING_NUMBER_INSTANCE, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => {
+                    expect(isStringIncludesSome(TESTING_STRING_INSTANCE, [TESTING_STRING, '!@#$%^&*()', '3'])).toBeTrue();
+
+                    // No word exists.
+                    expect(isStringIncludesSome(TESTING_STRING_LONG_INSTANCE, [
+                      'no text',
+                      'no text is here'
+                    ])).toBeFalse();
+
+                    // Every word exists.
+                    expect(isStringIncludesSome(TESTING_STRING_LONG_INSTANCE, [
+                      'Lorem',
+                      'unchanged',
+                      'versions',
+                      'only',
+                    ])).toBeTrue();
+
+                    // Some word exists.
+                    expect(isStringIncludesSome(TESTING_STRING_LONG_INSTANCE, [
+                      'Lorem',
+                      'unchanged',
+                      'versions',
+                      'only',
+                      'no text is here'
+                    ])).toBeTrue();
+                  }));
+            });
+        });
+    });
+});
diff --git a/src/is/test/is-string-includes.spec.ts b/src/is/test/is-string-includes.spec.ts
new file mode 100644
index 00000000..2716cff7
--- /dev/null
+++ b/src/is/test/is-string-includes.spec.ts
@@ -0,0 +1,190 @@
+// Function.
+import { isStringIncludes } from '../lib/is-string-includes.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.stringIncludes.describe,
+  tests.is.stringIncludes.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isStringIncludes.name, () => {
+  const TESTING_STRING_LONG = `Lorem Ipsum is simply dummy text of the printing and typesetting industry.
+  Lorem Ipsum has been the industry's standard dummy text ever since the 1500s,
+  when an unknown printer took a galley of type and scrambled it to make a type specimen book.
+  It has survived not only five centuries, but also the leap into electronic typesetting,
+  remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset
+  sheets containing Lorem Ipsum passages, and more recently with desktop publishing software
+  like Aldus PageMaker including versions of Lorem Ipsum.`;
+
+  const TESTING_STRING_LONG_INSTANCE = new String(TESTING_STRING_LONG);
+
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isStringIncludes).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isStringIncludes(TESTING_STRING, ['Company'], (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_STRING);
+            }
+            return result;
+          });
+        })
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isStringIncludes(TESTING_FUNCTION, [])).toBeFalse())
+            .it(`TestingClass`, () => expect(isStringIncludes(TestingClass, [])).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isStringIncludes(TESTING_CLASS, [])).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isStringIncludes(TESTING_OBJECT, [])).toBeFalse());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isStringIncludes(TESTING_BIGINT, [])).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isStringIncludes(TESTING_TRUE, [])).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isStringIncludes(TESTING_FALSE, [])).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isStringIncludes(TESTING_NULL, [])).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isStringIncludes(TESTING_NUMBER, [])).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isStringIncludes(TESTING_NUMBER_INSTANCE, [])).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => {
+                  expect(isStringIncludes(TESTING_STRING, ['Company'])).toBeTrue();
+                  expect(isStringIncludes(TESTING_STRING, [TESTING_STRING, '!@#$%^&*()'])).toBeTrue();
+                    // No word exists.
+                  expect(isStringIncludes(TESTING_STRING_LONG, [
+                    'no text',
+                    'no text is here'
+                  ])).toBeFalse();
+
+                  // Every word exists.
+                  expect(isStringIncludes(TESTING_STRING_LONG, [
+                    'Lorem',
+                    'unchanged',
+                    'versions',
+                    'only',
+                  ])).toBeTrue();
+
+                  // Some word exists.
+                  expect(isStringIncludes(TESTING_STRING_LONG, [
+                    'Lorem',
+                    'unchanged',
+                    'versions',
+                    'only',
+                    'no text is here'
+                  ])).toBeFalse();
+                })
+                .it(`String(${TESTING_STRING})`, () =>
+                  expect(isStringIncludes(TESTING_STRING_CONSTRUCTOR, [TESTING_STRING, '!@#$%^&*()'])).toBeTrue());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () =>
+                  expect(isStringIncludes(TESTING_SYMBOL_NUMBER, ['1', '2', '123123'])).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () =>
+                  expect(isStringIncludes(TESTING_SYMBOL_STRING, ['1', '2', '123123'])).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isStringIncludes(TESTING_UNDEFINED, [ '1', '2', '123123' ])).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () =>
+                  testing.it(`${TESTING_BIGINT}`, () => expect(isStringIncludes(TESTING_BIGINT, [ '1', '2', '123123' ])).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () =>
+                      expect(isStringIncludes(TESTING_TRUE_INSTANCE, [ '1', '2', '123123' ])).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () =>
+                      expect(isStringIncludes(TESTING_FALSE_INSTANCE, [])).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isStringIncludes(TESTING_NUMBER_INSTANCE, [])).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => {
+                    expect(isStringIncludes(TESTING_STRING_INSTANCE, [])).toBeTrue();
+
+                    // No word exists.
+                    expect(isStringIncludes(TESTING_STRING_LONG, [
+                      'no text',
+                      'no text is here'
+                    ])).toBeFalse();
+
+                    // Every word exists.
+                    expect(isStringIncludes(TESTING_STRING_LONG_INSTANCE, [
+                      'Lorem',
+                      'unchanged',
+                      'versions',
+                      'only',
+                    ])).toBeTrue();
+
+                    // Some word exists.
+                    expect(isStringIncludes(TESTING_STRING_LONG_INSTANCE, [
+                      'Lorem',
+                      'unchanged',
+                      'versions',
+                      'only',
+                      'no text is here'
+                    ])).toBeFalse();
+                }));
+            });
+        });
+    });
+});
diff --git a/src/is/test/is-string-length-between.spec.ts b/src/is/test/is-string-length-between.spec.ts
new file mode 100644
index 00000000..c194db75
--- /dev/null
+++ b/src/is/test/is-string-length-between.spec.ts
@@ -0,0 +1,154 @@
+// Function.
+import { isStringLengthBetween } from '../lib/is-string-length-between.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_ARRAY_STRING,
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_DATE,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.stringLengthBetween.describe,
+  tests.is.stringLengthBetween.it
+);
+/**
+ * Tests.
+ */
+testing.describe(`isStringLengthBetween()`, () => {
+  // Constant.
+  const min = 0;
+  const max = 13;
+  const stringFirstName = 'my first name';
+  const stringInstance = new String(stringFirstName);
+
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isStringLengthBetween).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isStringLengthBetween(TESTING_FALSE, min, max, (result: boolean) => {
+            expect(result).toBeFalse();
+            return result;
+          });
+        })
+        // ... arrays.
+        .describe(`array`, () => {
+          testing
+            .it(`TESTING_ARRAY_STRING`, () => expect(isStringLengthBetween(TESTING_ARRAY_STRING, min, max)).toBeFalse());
+        })
+        // ... Date.
+        .describe(`date`, () => {
+          testing
+            .it(`TESTING_DATE`, () => expect(isStringLengthBetween(TESTING_DATE, min, max)).toBeFalse())
+        })
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`FUNCTION ${min} ${max}`, () => expect(isStringLengthBetween(TESTING_FUNCTION, min, max)).toBeFalse())
+            .it(`TestingClass ${min} ${max}`, () => expect(isStringLengthBetween(TestingClass, min, max)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isStringLengthBetween(TESTING_CLASS, min, max)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isStringLengthBetween(TESTING_OBJECT, min, max)).toBeFalse());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => it(`${TESTING_BIGINT}`, () => expect(isStringLengthBetween(TESTING_BIGINT, min, max)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isStringLengthBetween(TESTING_TRUE, min, max)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isStringLengthBetween(TESTING_FALSE, min, max)).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isStringLengthBetween(TESTING_NULL, min, max)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isStringLengthBetween(TESTING_NUMBER, min, max)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isStringLengthBetween(TESTING_NUMBER_INSTANCE, min, max)).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isStringLengthBetween(TESTING_STRING, min, max)).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isStringLengthBetween(TESTING_STRING_INSTANCE, min, max)).toBeFalse())
+                .it(`${stringFirstName}`, () => expect(isStringLengthBetween(stringFirstName, min, max)).toBeTrue())
+                .it(`${stringFirstName}`, () => expect(isStringLengthBetween(stringFirstName, 13, max)).toBeTrue())
+                .it(`${stringFirstName}`, () => expect(isStringLengthBetween(stringFirstName, 14, max)).toBeFalse())
+                .it(`${stringFirstName}`, () => expect(isStringLengthBetween(stringFirstName, min, 12)).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isStringLengthBetween(TESTING_SYMBOL_NUMBER, min, max)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isStringLengthBetween(TESTING_SYMBOL_STRING, min, max)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isStringLengthBetween(TESTING_UNDEFINED, min, max)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt constructor`, () =>
+                  testing.it(`${TESTING_BIGINT}`, () => expect(isStringLengthBetween(BigInt(1n), min, max)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isStringLengthBetween(TESTING_TRUE_INSTANCE, min, max)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isStringLengthBetween(TESTING_FALSE_INSTANCE, min, max)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () => {
+                  testing
+                    .it(`new Number(${TESTING_NUMBER})`, () => expect(isStringLengthBetween(TESTING_NUMBER_INSTANCE, min, max)).toBeFalse())
+                    .it(`new Number(${stringFirstName})`, () => expect(isStringLengthBetween(new Number(stringFirstName), min, max)).toBeFalse())
+                    .it(`new Number(${stringFirstName})`, () => expect(isStringLengthBetween(new Number(1.15), min, max)).toBeFalse())
+                    .it(`new Number(${stringFirstName})`, () => expect(isStringLengthBetween(new Number(13.15), min, max)).toBeFalse());
+                })
+                // String
+                .describe(`String`, () => {
+                  testing
+                    .it(`new String(${TESTING_STRING})`, () => expect(isStringLengthBetween(TESTING_STRING_INSTANCE, min, max)).toBeFalse())
+                    .it(`new String(${stringFirstName})`, () => expect(isStringLengthBetween(stringInstance, min, max)).toBeTrue())
+                    .it(`new String(${stringFirstName})`, () => expect(isStringLengthBetween(stringInstance, 13, max)).toBeTrue())
+                    .it(`new String(${stringFirstName})`, () => expect(isStringLengthBetween(stringInstance, 14, max)).toBeFalse())
+                    .it(`new String(${stringFirstName})`, () => expect(isStringLengthBetween(stringInstance, min, 12)).toBeFalse());
+                });
+            });
+        });
+    });
+});
diff --git a/src/is/test/is-string-length.spec.ts b/src/is/test/is-string-length.spec.ts
new file mode 100644
index 00000000..ee5fb13a
--- /dev/null
+++ b/src/is/test/is-string-length.spec.ts
@@ -0,0 +1,153 @@
+// Function.
+import { isStringLength } from '../lib/is-string-length.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_ARRAY_STRING,
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_DATE,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.stringLength.describe,
+  tests.is.stringLength.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isStringLength.name, () => {
+  // Constant.
+  const length = 13;
+  const stringFirstName = 'my first name';
+  const stringInstance = new String(stringFirstName);
+
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isStringLength).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isStringLength(TESTING_FALSE, length, (result: boolean) => {
+            expect(result).toBeFalse();
+            return result;
+          });
+        })
+        // ... arrays.
+        .describe(`array`, () => {
+          testing
+            .it(`TESTING_ARRAY_STRING`, () => expect(isStringLength(TESTING_ARRAY_STRING, length)).toBeFalse());
+        })
+        // ... Date.
+        .describe(`date`, () => {
+          testing
+            .it(`TESTING_DATE`, () => expect(isStringLength(TESTING_DATE, length)).toBeFalse());
+        })
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`FUNCTION ${length}`, () => expect(isStringLength(TESTING_FUNCTION, length)).toBeFalse())
+            .it(`TestingClass ${length}`, () => expect(isStringLength(TestingClass, length)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isStringLength(TESTING_CLASS, length)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isStringLength(TESTING_OBJECT, length)).toBeFalse());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => it(`${TESTING_BIGINT}`, () => expect(isStringLength(TESTING_BIGINT, length)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isStringLength(TESTING_TRUE, length)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isStringLength(TESTING_FALSE, length)).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isStringLength(TESTING_NULL, length)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isStringLength(TESTING_NUMBER, length)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isStringLength(TESTING_NUMBER_INSTANCE, length)).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isStringLength(TESTING_STRING, length)).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isStringLength(TESTING_STRING_INSTANCE, length)).toBeFalse())
+                .it(`${stringFirstName}`, () => expect(isStringLength(stringFirstName, length)).toBeTrue())
+                .it(`${stringFirstName}`, () => expect(isStringLength(stringFirstName, 13)).toBeTrue())
+                .it(`${stringFirstName}`, () => expect(isStringLength(stringFirstName, 14)).toBeFalse())
+                .it(`${stringFirstName}`, () => expect(isStringLength(stringFirstName, 12)).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isStringLength(TESTING_SYMBOL_NUMBER, length)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isStringLength(TESTING_SYMBOL_STRING, length)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isStringLength(TESTING_UNDEFINED, length)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt constructor`, () =>
+                  testing.it(`${TESTING_BIGINT}`, () => expect(isStringLength(BigInt(1n), length)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isStringLength(TESTING_TRUE_INSTANCE, length)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isStringLength(TESTING_FALSE_INSTANCE, length)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () => {
+                  testing
+                    .it(`new Number(${TESTING_NUMBER})`, () => expect(isStringLength(TESTING_NUMBER_INSTANCE, length)).toBeFalse())
+                    .it(`new Number(${stringFirstName})`, () => expect(isStringLength(new Number(stringFirstName), length)).toBeFalse())
+                    .it(`new Number(${stringFirstName})`, () => expect(isStringLength(new Number(1.15), length)).toBeFalse())
+                    .it(`new Number(${stringFirstName})`, () => expect(isStringLength(new Number(13.15), length)).toBeFalse());
+                })
+                // String
+                .describe(`String`, () => {
+                  testing
+                    .it(`new String(${TESTING_STRING})`, () => expect(isStringLength(TESTING_STRING_INSTANCE, length)).toBeFalse())
+                    .it(`new String(${stringFirstName})`, () => expect(isStringLength(stringInstance, length)).toBeTrue())
+                    .it(`new String(${stringFirstName})`, () => expect(isStringLength(stringInstance, 13)).toBeTrue())
+                    .it(`new String(${stringFirstName})`, () => expect(isStringLength(stringInstance, 14)).toBeFalse())
+                    .it(`new String(${stringFirstName})`, () => expect(isStringLength(stringInstance, 12)).toBeFalse());
+                });
+            });
+        });
+    });
+});
diff --git a/src/is/test/is-string-object.spec.ts b/src/is/test/is-string-object.spec.ts
index ad3051a6..ee038ece 100644
--- a/src/is/test/is-string-object.spec.ts
+++ b/src/is/test/is-string-object.spec.ts
@@ -1,89 +1,127 @@
 // Function.
 import { isStringObject } from '../lib/is-string-object.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.stringObject.describe,
+  tests.is.stringObject.it
+);
 /**
  * Checks
  * ✓ typeof === 'object' && instanceof String === true && instanceof Object === true
  */
-describe(isStringObject.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isStringObject).toBeDefined());
+testing.describe(isStringObject.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isStringObject).toBeDefined())
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isStringObject(STRING_NEW_INSTANCE, (result: boolean, value: String) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(STRING_NEW_INSTANCE);
-        return result;
-      });
-    });
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isStringObject(TESTING_STRING_INSTANCE, (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_STRING_INSTANCE);
+            }
+            return result;
+          });
+        })
 
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isStringObject(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isStringObject(Class)).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isStringObject(CLASS)).toBe(FALSE));
-      it(`OBJECT_ONE`, () => expect(isStringObject(OBJECT_ONE)).toBe(FALSE));
-      it(`OBJECT_TWO`, () => expect(isStringObject(OBJECT_TWO)).toBe(FALSE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isStringObject(OBJECT_ONE_NEW)).toBe(FALSE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isStringObject(OBJECT_TWO_NEW)).toBe(FALSE));
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isStringObject(BIGINT)).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isStringObject(TRUE)).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isStringObject(FALSE)).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isStringObject(NULL)).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isStringObject(NUMBER)).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isStringObject(NUMBER_INSTANCE)).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isStringObject(STRING)).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isStringObject(STRING_INSTANCE)).toBe(FALSE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isStringObject(SYMBOL_NUMBER)).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isStringObject(SYMBOL_STRING)).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isStringObject(UNDEFINED)).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isStringObject(BIGINT_INSTANCE)).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isStringObject(TRUE_INSTANCE)).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isStringObject(FALSE_INSTANCE)).toBe(FALSE));
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isStringObject(TESTING_FUNCTION)).toBeFalse())
+            .it(`TestingClass`, () => expect(isStringObject(TestingClass)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isStringObject(TESTING_CLASS)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isStringObject(TESTING_OBJECT)).toBeFalse())
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isStringObject(TESTING_BIGINT)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isStringObject(TESTING_TRUE)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isStringObject(TESTING_FALSE)).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isStringObject(TESTING_NULL)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isStringObject(TESTING_NUMBER)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isStringObject(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isStringObject(TESTING_STRING)).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isStringObject(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isStringObject(TESTING_SYMBOL_NUMBER)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isStringObject(TESTING_SYMBOL_STRING)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isStringObject(TESTING_UNDEFINED)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isStringObject(TESTING_BIGINT)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isStringObject(TESTING_TRUE_INSTANCE)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isStringObject(TESTING_FALSE_INSTANCE)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isStringObject(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isStringObject(TESTING_STRING_INSTANCE)).toBeTrue()));
+            });
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isStringObject(NUMBER_NEW_INSTANCE)).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isStringObject(STRING_NEW_INSTANCE)).toBe(TRUE)));
-      });
     });
-  });
 });
diff --git a/src/is/test/is-string-type.spec.ts b/src/is/test/is-string-type.spec.ts
index 6c62675d..61684b89 100644
--- a/src/is/test/is-string-type.spec.ts
+++ b/src/is/test/is-string-type.spec.ts
@@ -1,94 +1,128 @@
 // Function.
 import { isStringType } from '../lib/is-string-type.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.stringType.describe,
+  tests.is.stringType.it
+);
 /**
- * Checks
- * ✓ typeof === 'string' && instanceof String === false && instanceof Object === false
+ * Tests.
  */
-describe(isStringType.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isStringType).toBeDefined());
+testing.describe(isStringType.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isStringType).toBeDefined())
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isStringType(STRING, (result: boolean, value: any) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(STRING);
-        return result;
-      });
-    });
-    // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isStringType(FUNCTION, 'function')).toBe(FALSE));
-      // it(`${Class}`, () => expect(isStringType(Class, 'function')).toBe(FALSE));
-    });
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isStringType(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isStringType(Class)).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isStringType(CLASS)).toBe(FALSE));
-      it(`OBJECT_ONE`, () => expect(isStringType(OBJECT_ONE)).toBe(FALSE));
-      it(`OBJECT_TWO`, () => expect(isStringType(OBJECT_TWO)).toBe(FALSE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isStringType(OBJECT_ONE_NEW)).toBe(FALSE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isStringType(OBJECT_TWO_NEW)).toBe(FALSE));
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isStringType(BIGINT)).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isStringType(TRUE)).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isStringType(FALSE)).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isStringType(NULL)).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isStringType(NUMBER)).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isStringType(NUMBER_INSTANCE)).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isStringType(STRING)).toBe(TRUE));
-        it(`String(${STRING})`, () => expect(isStringType(STRING_INSTANCE)).toBe(TRUE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isStringType(SYMBOL_NUMBER)).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isStringType(SYMBOL_STRING)).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isStringType(UNDEFINED)).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isStringType(BIGINT_INSTANCE)).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isStringType(TRUE_INSTANCE)).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isStringType(FALSE_INSTANCE)).toBe(FALSE));
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isStringType(TESTING_STRING, (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_STRING);
+            }
+            return result;
+          });
+        })
+        // ... arrays.
+        .describe(`array`, () => {})
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isStringType(TESTING_FUNCTION)).toBeFalse())
+            .it(`TestingClass`, () => expect(isStringType(TestingClass)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isStringType(TESTING_CLASS)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isStringType(TESTING_OBJECT)).toBeFalse())
+            .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isStringType(TESTING_OBJECT)).toBeFalse());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isStringType(TESTING_BIGINT)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isStringType(TESTING_TRUE)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isStringType(TESTING_FALSE)).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isStringType(TESTING_NULL)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isStringType(TESTING_NUMBER)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isStringType(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isStringType(TESTING_STRING)).toBeTrue())
+                .it(`String(${TESTING_STRING})`, () => expect(isStringType(TESTING_STRING_CONSTRUCTOR)).toBeTrue());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isStringType(TESTING_SYMBOL_NUMBER)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isStringType(TESTING_SYMBOL_STRING)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isStringType(TESTING_UNDEFINED)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isStringType(TESTING_BIGINT)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isStringType(TESTING_TRUE_INSTANCE)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isStringType(TESTING_FALSE_INSTANCE)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isStringType(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isStringType(TESTING_STRING_INSTANCE)).toBeFalse()));
+            });
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isStringType(NUMBER_NEW_INSTANCE)).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isStringType(STRING_NEW_INSTANCE)).toBe(FALSE)));
-      });
     });
-  });
 });
diff --git a/src/is/test/is-string.spec.ts b/src/is/test/is-string.spec.ts
index 35893e4b..9789a704 100644
--- a/src/is/test/is-string.spec.ts
+++ b/src/is/test/is-string.spec.ts
@@ -1,95 +1,128 @@
 // Function.
 import { isString } from '../lib/is-string.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.string.describe,
+  tests.is.string.it
+);
 /**
- * Checks
- * ✓ typeof === 'string' && instanceof String === false && instanceof Object === false
- * ✓ typeof === 'object' && instanceof String === true && instanceof Object === true
+ * Tests.
  */
-describe(isString.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isString).toBeDefined());
+testing.describe(isString.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isString).toBeDefined())
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isString(STRING, (result: boolean, value: any) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(STRING);
-        return result;
-      });
-    });
-    // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isString(FUNCTION, 'function')).toBe(FALSE));
-      // it(`${Class}`, () => expect(isString(Class, 'function')).toBe(FALSE));
-    });
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isString(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isString(Class)).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isString(CLASS)).toBe(FALSE));
-      it(`OBJECT_ONE`, () => expect(isString(OBJECT_ONE)).toBe(FALSE));
-      it(`OBJECT_TWO`, () => expect(isString(OBJECT_TWO)).toBe(FALSE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isString(OBJECT_ONE_NEW)).toBe(FALSE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isString(OBJECT_TWO_NEW)).toBe(FALSE));
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isString(BIGINT)).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isString(TRUE)).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isString(FALSE)).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isString(NULL)).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isString(NUMBER)).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isString(NUMBER_INSTANCE)).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isString(STRING)).toBe(TRUE));
-        it(`String(${STRING})`, () => expect(isString(STRING_INSTANCE)).toBe(TRUE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isString(SYMBOL_NUMBER)).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isString(SYMBOL_STRING)).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isString(UNDEFINED)).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isString(BIGINT_INSTANCE)).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isString(TRUE_INSTANCE)).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isString(FALSE_INSTANCE)).toBe(FALSE));
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isString(TESTING_STRING, (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_STRING);
+            }
+            return result;
+          });
+        })
+        // ... arrays.
+        .describe(`array`, () => {})
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isString(TESTING_FUNCTION)).toBeFalse())
+            .it(`TestingClass`, () => expect(isString(TestingClass)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isString(TESTING_CLASS)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isString(TESTING_OBJECT)).toBeFalse())
+            .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isString(TESTING_OBJECT)).toBeFalse());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isString(TESTING_BIGINT)).toBeFalse()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isString(TESTING_TRUE)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isString(TESTING_FALSE)).toBeFalse());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isString(TESTING_NULL)).toBeFalse())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isString(TESTING_NUMBER)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isString(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isString(TESTING_STRING)).toBeTrue())
+                .it(`String(${TESTING_STRING})`, () => expect(isString(TESTING_STRING_CONSTRUCTOR)).toBeTrue());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isString(TESTING_SYMBOL_NUMBER)).toBeFalse())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isString(TESTING_SYMBOL_STRING)).toBeFalse());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isString(TESTING_UNDEFINED)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isString(TESTING_BIGINT)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isString(TESTING_TRUE_INSTANCE)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isString(TESTING_FALSE_INSTANCE)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isString(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isString(TESTING_STRING_INSTANCE)).toBeTrue()));
+            });
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isString(NUMBER_NEW_INSTANCE)).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isString(STRING_NEW_INSTANCE)).toBe(TRUE)));
-      });
     });
-  });
 });
diff --git a/src/is/test/is-symbol.spec.ts b/src/is/test/is-symbol.spec.ts
index edce37c7..3375aabd 100644
--- a/src/is/test/is-symbol.spec.ts
+++ b/src/is/test/is-symbol.spec.ts
@@ -1,97 +1,129 @@
 // Function.
 import { isSymbol } from '../lib/is-symbol.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.symbol.describe,
+  tests.is.symbol.it
+);
 /**
- * Checks
- * ✓ typeof === 'symbol'
+ * Tests.
  */
-describe(isSymbol.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isSymbol).toBeDefined());
+testing.describe(isSymbol.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isSymbol).toBeDefined())
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isSymbol(SYMBOL_NUMBER, (result: boolean) => {
-        expect(result).toBe(TRUE);
-        return result;
-      });
-    });
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isSymbol(TESTING_SYMBOL_NUMBER, (result: boolean) => {
+            expect(result).toBeTrue();
+            return result;
+          });
+        })
 
-    // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isSymbol(FUNCTION, 'function')).toBe(FALSE));
-      // it(`${Class}`, () => expect(isSymbol(Class, 'function')).toBe(FALSE));
-    });
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isSymbol(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isSymbol(Class)).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isSymbol(CLASS)).toBe(FALSE));
-      it(`OBJECT_ONE`, () => expect(isSymbol(OBJECT_ONE)).toBe(FALSE));
-      it(`OBJECT_TWO`, () => expect(isSymbol(OBJECT_TWO)).toBe(FALSE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isSymbol(OBJECT_ONE_NEW)).toBe(FALSE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isSymbol(OBJECT_TWO_NEW)).toBe(FALSE));
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isSymbol(BIGINT)).toBe(FALSE)));
+        // ... arrays.
+        .describe(`array`, () => {})
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`TESTING_FUNCTION`, () => expect(isSymbol(TESTING_FUNCTION)).toBeFalse())
+            .it(`TestingClass`, () => expect(isSymbol(TestingClass)).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isSymbol(TESTING_CLASS)).toBeFalse())
+            .it(`TESTING_OBJECT`, () => expect(isSymbol(TESTING_OBJECT)).toBeFalse())
+            .it(`new Object(OBJECT_ONE_NEW})`, () => expect(isSymbol(TESTING_OBJECT)).toBeFalse());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isSymbol(TESTING_BIGINT)).toBeFalse()))
 
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isSymbol(TRUE)).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isSymbol(FALSE)).toBe(FALSE));
-      });
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isSymbol(TESTING_TRUE)).toBeFalse())
+                .it(`${TESTING_FALSE}`, () => expect(isSymbol(TESTING_FALSE)).toBeFalse());
+            })
 
-      // null
-      it(`${NULL}`, () => expect(isSymbol(NULL)).toBe(FALSE));
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isSymbol(TESTING_NULL)).toBeFalse())
 
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isSymbol(NUMBER)).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isSymbol(NUMBER_INSTANCE)).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isSymbol(STRING)).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isSymbol(STRING_INSTANCE)).toBe(FALSE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isSymbol(SYMBOL_NUMBER)).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(isSymbol(SYMBOL_STRING)).toBe(TRUE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isSymbol(UNDEFINED)).toBe(FALSE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isSymbol(BIGINT_INSTANCE)).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isSymbol(TRUE_INSTANCE)).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isSymbol(FALSE_INSTANCE)).toBe(FALSE));
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isSymbol(TESTING_NUMBER)).toBeFalse())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isSymbol(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isSymbol(TESTING_STRING)).toBeFalse())
+                .it(`String(${TESTING_STRING})`, () => expect(isSymbol(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isSymbol(TESTING_SYMBOL_NUMBER)).toBeTrue())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isSymbol(TESTING_SYMBOL_STRING)).toBeTrue());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isSymbol(TESTING_UNDEFINED)).toBeFalse())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isSymbol(TESTING_BIGINT)).toBeFalse()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isSymbol(TESTING_TRUE_INSTANCE)).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isSymbol(TESTING_FALSE_INSTANCE)).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isSymbol(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isSymbol(TESTING_STRING_INSTANCE)).toBeFalse()));
+            });
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isSymbol(NUMBER_NEW_INSTANCE)).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isSymbol(STRING_NEW_INSTANCE)).toBe(FALSE)));
-      });
     });
-  });
 });
diff --git a/src/is/test/is-true.spec.ts b/src/is/test/is-true.spec.ts
new file mode 100644
index 00000000..574b5ded
--- /dev/null
+++ b/src/is/test/is-true.spec.ts
@@ -0,0 +1,117 @@
+// Function.
+import { isTrue } from '../lib/is-true.func';
+// Testing.
+import {
+  // Main.
+  Testing,
+
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_DATE,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.true.describe,
+  tests.is.true.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isTrue.name, () => {
+  // Defined.
+  it('is DEFINED', () => expect(isTrue).toBeDefined());
+
+  // Checks ...
+  describe(`checks`, () => {
+    it('callback', () => {
+      isTrue(TESTING_TRUE, (result: boolean) => {
+        expect(result).toBeTrue();
+        return result;
+      });
+    });
+    // ... arrays.
+    describe(`array`, () => {});
+    // ... Date.
+    describe(`date`, () => {
+      it(`TESTING_DATE`, () => expect(isTrue(TESTING_DATE)).toBeFalse());
+    });
+    // ... function.
+    describe(`function`, () => {
+      it(`TESTING_FUNCTION`, () => expect(isTrue(TESTING_FUNCTION)).toBeFalse());
+      it(`TestingClass`, () => expect(isTrue(TestingClass)).toBeFalse());
+    });
+    // ... objects.
+    describe('object', () => {
+      it(`TESTING_CLASS`, () => expect(isTrue(TESTING_CLASS)).toBeFalse());
+      it(`TESTING_OBJECT`, () => expect(isTrue(TESTING_OBJECT)).toBeFalse());
+      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isTrue(TESTING_OBJECT)).toBeFalse());
+    });
+    // ... primitives.
+    describe(`primitive`, () => {
+      // bigint
+      describe(`bigint`, () => it(`${TESTING_BIGINT}`, () => expect(isTrue(TESTING_BIGINT)).toBeFalse()));
+      // boolean
+      describe(`boolean`, () => {
+        it(`${TESTING_TRUE}`, () => expect(isTrue(TESTING_TRUE)).toBeTrue());
+        it(`${TESTING_FALSE}`, () => expect(isTrue(TESTING_FALSE)).toBeFalse());
+      });
+      // null
+      it(`${TESTING_NULL}`, () => expect(isTrue(TESTING_NULL)).toBeFalse());
+      // number
+      describe(`number`, () => {
+        it(`${TESTING_NUMBER}`, () => expect(isTrue(TESTING_NUMBER)).toBeFalse());
+        it(`Number(${TESTING_NUMBER})`, () => expect(isTrue(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+      });
+      // string
+      describe(`string`, () => {
+        it(`${TESTING_STRING}`, () => expect(isTrue(TESTING_STRING)).toBeFalse());
+        it(`String(${TESTING_STRING})`, () => expect(isTrue(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+      });
+      // symbol
+      describe(`symbol`, () => {
+        it(`Symbol(${TESTING_NUMBER})`, () => expect(isTrue(TESTING_SYMBOL_NUMBER)).toBeFalse());
+        it(`Symbol(${TESTING_STRING})`, () => expect(isTrue(TESTING_SYMBOL_STRING)).toBeFalse());
+      });
+      // undefined
+      it(`${TESTING_UNDEFINED}`, () => expect(isTrue(TESTING_UNDEFINED)).toBeFalse());
+      // ... object.
+      describe(`object`, () => {
+        // BigInt
+        describe(`BigInt`, () => it(`${TESTING_BIGINT}`, () => expect(isTrue(TESTING_BIGINT)).toBeFalse()));
+        // Boolean
+        describe(`Boolean`, () => {
+          it(`${TESTING_TRUE_INSTANCE}`, () => expect(isTrue(TESTING_TRUE_INSTANCE)).toBeTrue());
+          it(`${TESTING_FALSE_INSTANCE}`, () => expect(isTrue(TESTING_FALSE_INSTANCE)).toBeFalse());
+        });
+        // Number
+        describe(`Number`, () => it(`new Number(${TESTING_NUMBER})`, () => expect(isTrue(TESTING_NUMBER_INSTANCE)).toBeFalse()));
+        // String
+        describe(`String`, () => it(`new String(${TESTING_STRING})`, () => expect(isTrue(TESTING_STRING_INSTANCE)).toBeFalse()));
+      });
+    });
+  });
+});
diff --git a/src/is/test/is-type.spec.ts b/src/is/test/is-type.spec.ts
index 4fbc161f..9f758ef3 100644
--- a/src/is/test/is-type.spec.ts
+++ b/src/is/test/is-type.spec.ts
@@ -1,95 +1,134 @@
 // Function.
 import { isType } from '../lib/is-type.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, TRUE_INSTANCE, FALSE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
-// Interface.
-import { ObjectOne } from '../../testing/interface/object-one.interface';
-import { ObjectTwo } from '../../testing/interface/object-two.interface';
+// Testing.
+import {
+  // Main.
+  Testing,
 
-describe(isType.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isType).toBeDefined());
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
 
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isType(STRING, 'string', (result: boolean, value: any) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(STRING);
-        return result;
-      });
-      isType(NUMBER, 'number', (result: boolean, value: any) => {
-        expect(result).toBe(TRUE);
-        expect(value).toEqual(NUMBER);
-        return result;
-      });
-    });
-    // ... instance.
-    describe(`instance`, () => it(`Class`, () => expect(isType<Class>(CLASS, Class)).toBe(TRUE)));
-    // ... function.
-    describe(`function`, () => {
-      it(`${FUNCTION}`, () => expect(isType(FUNCTION, 'function')).toBe(TRUE));
-      it(`${CLASS}`, () => expect(isType(Class, 'function')).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isType(CLASS, 'object')).toBe(TRUE));
-      it(`OBJECT_ONE`, () => expect(isType<ObjectOne>(OBJECT_ONE, 'object')).toBe(TRUE));
-      it(`OBJECT_ONE_NEW`, () => expect(isType<ObjectTwo>(OBJECT_TWO, 'object')).toBe(TRUE));
-      it(`new Object(OBJECT_ONE_NEW)`, () => expect(isType<ObjectOne>(OBJECT_ONE_NEW, 'object')).toBe(TRUE));
-      it(`new Object(OBJECT_TWO_NEW)`, () => expect(isType<ObjectTwo>(OBJECT_TWO_NEW, 'object')).toBe(TRUE));
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isType(BIGINT, 'bigint')).toBe(TRUE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isType(TRUE, 'boolean')).toBe(TRUE));
-        it(`${FALSE}`, () => expect(isType(FALSE, 'boolean')).toBe(TRUE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isType(NULL, 'null')).toBe(TRUE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isType(NUMBER, 'number')).toBe(TRUE));
-        it(`Number(${NUMBER})`, () => expect(isType(NUMBER_INSTANCE, 'number')).toBe(TRUE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isType(STRING, 'string')).toBe(TRUE));
-        it(`String(${STRING})`, () => expect(isType(STRING_INSTANCE, 'string')).toBe(TRUE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isType(SYMBOL_NUMBER, 'symbol')).toBe(TRUE));
-        it(`Symbol(${STRING})`, () => expect(isType(SYMBOL_STRING, 'symbol')).toBe(TRUE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isType(UNDEFINED, 'undefined')).toBe(TRUE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isType(BIGINT_INSTANCE, 'bigint')).toBe(TRUE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isType(TRUE_INSTANCE, 'boolean')).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isType(FALSE_INSTANCE, 'boolean')).toBe(FALSE));
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.is.type.describe,
+  tests.is.type.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isType.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isType).toBeDefined())
+
+    // Checks ...
+    .describe(`checks`, () => {
+      testing
+        .it('callback', () => {
+          isType(TESTING_STRING, 'string', (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_STRING);
+            }
+            return result;
+          });
+          isType(TESTING_NUMBER, 'number', (result, value, payload) => {
+            expect(result).toBeTrue();
+            if (payload) {
+              expect(value).toEqual(TESTING_NUMBER);
+            }
+            return result;
+          });
+        })
+        // ... instance.
+        .describe(`instance`, () => testing.it(`TestingClass`, () => expect(isType<TestingClass>(TESTING_CLASS, TestingClass)).toBeTrue()))
+        // ... function.
+        .describe(`function`, () => {
+          testing
+            .it(`${TESTING_FUNCTION}`, () => expect(isType(TESTING_FUNCTION, 'function')).toBeTrue())
+            .it(`${TESTING_CLASS}`, () => expect(isType(TestingClass, 'function')).toBeFalse());
+        })
+        // ... objects.
+        .describe('object', () => {
+          testing
+            .it(`TESTING_CLASS`, () => expect(isType(TESTING_CLASS, 'object')).toBeTrue())
+            .it(`TESTING_OBJECT`, () => expect(isType(TESTING_OBJECT, 'object')).toBeTrue());
+        })
+        // ... primitives.
+        .describe(`primitive`, () => {
+          testing
+            // bigint
+            .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isType(TESTING_BIGINT, 'bigint')).toBeTrue()))
+            // boolean
+            .describe(`boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE}`, () => expect(isType(TESTING_TRUE, 'boolean')).toBeTrue())
+                .it(`${TESTING_FALSE}`, () => expect(isType(TESTING_FALSE, 'boolean')).toBeTrue());
+            })
+            // null
+            .it(`${TESTING_NULL}`, () => expect(isType(TESTING_NULL, 'null')).toBeTrue())
+            // number
+            .describe(`number`, () => {
+              testing
+                .it(`${TESTING_NUMBER}`, () => expect(isType(TESTING_NUMBER, 'number')).toBeTrue())
+                .it(`Number(${TESTING_NUMBER})`, () => expect(isType(TESTING_NUMBER_CONSTRUCTOR, 'number')).toBeTrue());
+            })
+            // string
+            .describe(`string`, () => {
+              testing
+                .it(`${TESTING_STRING}`, () => expect(isType(TESTING_STRING, 'string')).toBeTrue())
+                .it(`String(${TESTING_STRING})`, () => expect(isType(TESTING_STRING_CONSTRUCTOR, 'string')).toBeTrue());
+            })
+            // symbol
+            .describe(`symbol`, () => {
+              testing
+                .it(`Symbol(${TESTING_NUMBER})`, () => expect(isType(TESTING_SYMBOL_NUMBER, 'symbol')).toBeTrue())
+                .it(`Symbol(${TESTING_STRING})`, () => expect(isType(TESTING_SYMBOL_STRING, 'symbol')).toBeTrue());
+            })
+            // undefined
+            .it(`${TESTING_UNDEFINED}`, () => expect(isType(TESTING_UNDEFINED, 'undefined')).toBeTrue())
+            // ... object.
+            .describe(`object`, () => {
+              testing
+                // BigInt
+                .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isType(TESTING_BIGINT, 'bigint')).toBeTrue()))
+                // Boolean
+                .describe(`Boolean`, () => {
+                  testing
+                    .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isType(TESTING_TRUE_INSTANCE, 'boolean')).toBeFalse())
+                    .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isType(TESTING_FALSE_INSTANCE, 'boolean')).toBeFalse());
+                })
+                // Number
+                .describe(`Number`, () =>
+                  testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isType(TESTING_NUMBER_INSTANCE, 'number')).toBeFalse()))
+                // String
+                .describe(`String`, () =>
+                  testing.it(`new String(${TESTING_STRING})`, () => expect(isType(TESTING_STRING_INSTANCE, 'string')).toBeFalse()));
+            });
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isType(NUMBER_NEW_INSTANCE, 'number')).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isType(STRING_NEW_INSTANCE, 'string')).toBe(FALSE)));
-      });
     });
-  });
 });
diff --git a/src/is/test/is-undefined.spec.ts b/src/is/test/is-undefined.spec.ts
index 0e9e1e74..ddb50fd0 100644
--- a/src/is/test/is-undefined.spec.ts
+++ b/src/is/test/is-undefined.spec.ts
@@ -1,96 +1,127 @@
 // Function.
 import { isUndefined } from '../lib/is-undefined.func';
-// Constant.
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../../testing/src/big-int.const';
-import { Class, CLASS } from '../../testing/src/class.const';
-import { FALSE, TRUE, FALSE_INSTANCE, TRUE_INSTANCE, FALSE_EXPECTATION, TRUE_EXPECTATION } from '../../testing/src/boolean.const';
-import { FUNCTION } from '../../testing/src/function.const';
-import { NULL } from '../../testing/src/null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../../testing/src/number.const';
-import { OBJECT_ONE, OBJECT_TWO, OBJECT_ONE_NEW, OBJECT_TWO_NEW } from '../../testing/src/object.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../../testing/src/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../../testing/src/symbol.const';
-import { UNDEFINED } from '../../testing/src/undefined.const';
+// Testing.
+import {
+  // Main.
+  Testing,
 
+  // Constant.
+  TESTING_BIGINT,
+  TESTING_CLASS,
+  TESTING_FALSE,
+  TESTING_FALSE_INSTANCE,
+  TESTING_FUNCTION,
+  TESTING_NULL,
+  TESTING_NUMBER,
+  TESTING_NUMBER_CONSTRUCTOR,
+  TESTING_NUMBER_INSTANCE,
+  TESTING_OBJECT,
+  TESTING_STRING,
+  TESTING_STRING_CONSTRUCTOR,
+  TESTING_STRING_INSTANCE,
+  TESTING_SYMBOL_NUMBER,
+  TESTING_SYMBOL_STRING,
+  TESTING_TRUE,
+  TESTING_TRUE_INSTANCE,
+  TESTING_UNDEFINED,
+
+  // Class.
+  TestingClass,
+} from '@angular-package/testing';
+// Execute tests.
+import { tests } from '../../execute-tests';
 /**
- * Checks
- * ✓ typeOf() = 'undefined
- * ✓ typeof === 'undefined'
- * ✓ value === undefined
+ * Initialize testing.
  */
-describe(isUndefined.name, () => {
-  // Defined.
-  it('is DEFINED', () => expect(isUndefined).toBeDefined());
-
-  // Checks ...
-  describe(`checks`, () => {
-    it('callback', () => {
-      isUndefined(STRING, (result: boolean) => {
-        expect(result).toBe(FALSE);
-        return result;
-      });
-    });
+const testing = new Testing(
+  tests.is.undefined.describe,
+  tests.is.undefined.it
+);
+/**
+ * Tests.
+ */
+testing.describe(isUndefined.name, () => {
+  testing
+    // Defined.
+    .it('is DEFINED', () => expect(isUndefined).toBeDefined())
 
-    // ... arrays.
-    describe(`array`, () => {
-      // it(`${FUNCTION}`, () => expect(isUndefined(FUNCTION, 'function')).toBe(FALSE));
-      // it(`${Class}`, () => expect(isUndefined(Class, 'function')).toBe(FALSE));
-    });
-    // ... function.
-    describe(`function`, () => {
-      it(`FUNCTION`, () => expect(isUndefined(FUNCTION)).toBe(FALSE));
-      it(`Class`, () => expect(isUndefined(Class)).toBe(FALSE));
-    });
-    // ... objects.
-    describe('object', () => {
-      it(`CLASS`, () => expect(isUndefined(CLASS)).toBe(FALSE));
-      it(`OBJECT_ONE`, () => expect(isUndefined(OBJECT_ONE)).toBe(FALSE));
-      it(`OBJECT_TWO`, () => expect(isUndefined(OBJECT_TWO)).toBe(FALSE));
-      it(`new Object(OBJECT_ONE_NEW})`, () => expect(isUndefined(OBJECT_ONE_NEW)).toBe(FALSE));
-      it(`new Object(OBJECT_TWO_NEW})`, () => expect(isUndefined(OBJECT_TWO_NEW)).toBe(FALSE));
-    });
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => it(`${BIGINT}`, () => expect(isUndefined(BIGINT)).toBe(FALSE)));
-      // boolean
-      describe(`boolean`, () => {
-        it(`${TRUE}`, () => expect(isUndefined(TRUE)).toBe(FALSE));
-        it(`${FALSE}`, () => expect(isUndefined(FALSE)).toBe(FALSE));
-      });
-      // null
-      it(`${NULL}`, () => expect(isUndefined(NULL)).toBe(FALSE));
-      // number
-      describe(`number`, () => {
-        it(`${NUMBER}`, () => expect(isUndefined(NUMBER)).toBe(FALSE));
-        it(`Number(${NUMBER})`, () => expect(isUndefined(NUMBER_INSTANCE)).toBe(FALSE));
-      });
-      // string
-      describe(`string`, () => {
-        it(`${STRING}`, () => expect(isUndefined(STRING)).toBe(FALSE));
-        it(`String(${STRING})`, () => expect(isUndefined(STRING_INSTANCE)).toBe(FALSE));
-      });
-      // symbol
-      describe(`symbol`, () => {
-        it(`Symbol(${NUMBER})`, () => expect(isUndefined(SYMBOL_NUMBER)).toBe(FALSE));
-        it(`Symbol(${STRING})`, () => expect(isUndefined(SYMBOL_STRING)).toBe(FALSE));
-      });
-      // undefined
-      it(`${UNDEFINED}`, () => expect(isUndefined(UNDEFINED)).toBe(TRUE));
-      // ... object.
-      describe(`object`, () => {
-        // BigInt
-        describe(`BigInt`, () => it(`${BIGINT_EXPECTATION}`, () => expect(isUndefined(BIGINT_INSTANCE)).toBe(FALSE)));
-        // Boolean
-        describe(`Boolean`, () => {
-          it(`${TRUE_EXPECTATION}`, () => expect(isUndefined(TRUE_INSTANCE)).toBe(FALSE));
-          it(`${FALSE_EXPECTATION}`, () => expect(isUndefined(FALSE_INSTANCE)).toBe(FALSE));
+    // Checks ...
+    .describe(`checks`, () => {
+      testing.it('callback', () => {
+        isUndefined(TESTING_STRING, (result: boolean) => {
+          expect(result).toBeFalse();
+          return result;
         });
-        // Number
-        describe(`Number`, () => it(`new Number(${NUMBER})`, () => expect(isUndefined(NUMBER_NEW_INSTANCE)).toBe(FALSE)));
-        // String
-        describe(`String`, () => it(`new String(${STRING})`, () => expect(isUndefined(STRING_NEW_INSTANCE)).toBe(FALSE)));
+      })
+
+      // ... arrays.
+      .describe(`array`, () => {})
+
+      // ... function.
+      .describe(`function`, () => {
+        testing
+          .it(`TESTING_FUNCTION`, () => expect(isUndefined(TESTING_FUNCTION)).toBeFalse())
+          .it(`TestingClass`, () => expect(isUndefined(TestingClass)).toBeFalse());
+      })
+
+      // ... objects.
+      .describe('object', () => {
+        testing
+          .it(`TESTING_CLASS`, () => expect(isUndefined(TESTING_CLASS)).toBeFalse())
+          .it(`TESTING_OBJECT`, () => expect(isUndefined(TESTING_OBJECT)).toBeFalse());
+      })
+
+      // ... primitives.
+      .describe(`primitive`, () => {
+        testing
+          // bigint
+          .describe(`bigint`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isUndefined(TESTING_BIGINT)).toBeFalse()))
+          // boolean
+          .describe(`boolean`, () => {
+            testing
+              .it(`${TESTING_TRUE}`, () => expect(isUndefined(TESTING_TRUE)).toBeFalse())
+              .it(`${TESTING_FALSE}`, () => expect(isUndefined(TESTING_FALSE)).toBeFalse());
+          })
+          // null
+          .it(`${TESTING_NULL}`, () => expect(isUndefined(TESTING_NULL)).toBeFalse())
+          // number
+          .describe(`number`, () => {
+            testing
+              .it(`${TESTING_NUMBER}`, () => expect(isUndefined(TESTING_NUMBER)).toBeFalse())
+              .it(`Number(${TESTING_NUMBER})`, () => expect(isUndefined(TESTING_NUMBER_CONSTRUCTOR)).toBeFalse());
+          })
+          // string
+          .describe(`string`, () => {
+            testing
+              .it(`${TESTING_STRING}`, () => expect(isUndefined(TESTING_STRING)).toBeFalse())
+              .it(`String(${TESTING_STRING})`, () => expect(isUndefined(TESTING_STRING_CONSTRUCTOR)).toBeFalse());
+          })
+          // symbol
+          .describe(`symbol`, () => {
+            testing
+              .it(`Symbol(${TESTING_NUMBER})`, () => expect(isUndefined(TESTING_SYMBOL_NUMBER)).toBeFalse())
+              .it(`Symbol(${TESTING_STRING})`, () => expect(isUndefined(TESTING_SYMBOL_STRING)).toBeFalse());
+          })
+          // undefined
+          .it(`${TESTING_UNDEFINED}`, () => expect(isUndefined(TESTING_UNDEFINED)).toBeTrue())
+          // ... object.
+          .describe(`object`, () => {
+            testing
+            // BigInt
+            .describe(`BigInt`, () => testing.it(`${TESTING_BIGINT}`, () => expect(isUndefined(TESTING_BIGINT)).toBeFalse()))
+            // Boolean
+            .describe(`Boolean`, () => {
+              testing
+                .it(`${TESTING_TRUE_INSTANCE}`, () => expect(isUndefined(TESTING_TRUE_INSTANCE)).toBeFalse())
+                .it(`${TESTING_FALSE_INSTANCE}`, () => expect(isUndefined(TESTING_FALSE_INSTANCE)).toBeFalse());
+            })
+            // Number
+            .describe(`Number`, () =>
+              testing.it(`new Number(${TESTING_NUMBER})`, () => expect(isUndefined(TESTING_NUMBER_INSTANCE)).toBeFalse()))
+            // String
+            .describe(`String`, () =>
+              testing.it(`new String(${TESTING_STRING})`, () => expect(isUndefined(TESTING_STRING_INSTANCE)).toBeFalse()));
+          });
       });
     });
-  });
 });
diff --git a/src/is/test/is.spec.ts b/src/is/test/is.spec.ts
index 4b409ce3..f0294a94 100644
--- a/src/is/test/is.spec.ts
+++ b/src/is/test/is.spec.ts
@@ -1,31 +1,51 @@
 // Object.
 import { is } from '../lib/is.object';
-
-describe('`is`', () => {
-   describe('DEFINED', () => {
-      it('is', () => expect(is).toBeDefined());
-      it('is.array()', () => expect(is.array).toBeDefined());
-      it('is.boolean()', () => expect(is.boolean).toBeDefined());
-      it('is.booleanObject()', () => expect(is.booleanObject).toBeDefined());
-      it('is.booleanType()', () => expect(is.booleanType).toBeDefined());
-      it('is.defined()', () => expect(is.defined).toBeDefined());
-      it('is.function()', () => expect(is.function).toBeDefined());
-      it('is.instance()', () => expect(is.instance).toBeDefined());
-      it('is.key()', () => expect(is.key).toBeDefined());
-      it('is.null()', () => expect(is.null).toBeDefined());
-      it('is.number()', () => expect(is.number).toBeDefined());
-      it('is.numberObject()', () => expect(is.numberObject).toBeDefined());
-      it('is.numberType()', () => expect(is.numberType).toBeDefined());
-      it('is.object()', () => expect(is.object).toBeDefined());
-      it('is.objectKey()', () => expect(is.objectKey).toBeDefined());
-      it('is.objectKeyIn()', () => expect(is.objectKeyIn).toBeDefined());
-      it('is.objectKeys()', () => expect(is.objectKeys).toBeDefined());
-      it('is.primitive()', () => expect(is.primitive).toBeDefined());
-      it('is.string()', () => expect(is.string).toBeDefined());
-      it('is.stringObject()', () => expect(is.stringObject).toBeDefined());
-      it('is.stringType()', () => expect(is.stringType).toBeDefined());
-      it('is.symbol()', () => expect(is.symbol).toBeDefined());
-      it('is.type()', () => expect(is.type).toBeDefined());
-      it('is.undefined()', () => expect(is.undefined).toBeDefined());
+// Testing.
+import { Testing } from '@angular-package/testing';
+import { tests } from '../../execute-tests';
+/**
+ * Initialize testing.
+ */
+const testing = new Testing(
+  tests.object.is.describe,
+  tests.object.is.it
+);
+/**
+ * Tests.
+ */
+testing.describe('`is{}`', () => {
+  testing
+    .describe('DEFINED', () => {
+      testing
+      .it('is', () => expect(is).toBeDefined())
+      .it('is.array()', () => expect(is.array).toBeDefined())
+      .it('is.boolean()', () => expect(is.boolean).toBeDefined())
+      .it('is.booleanObject()', () => expect(is.booleanObject).toBeDefined())
+      .it('is.booleanType()', () => expect(is.booleanType).toBeDefined())
+      .it('is.date()', () => expect(is.date).toBeDefined())
+      .it('is.defined()', () => expect(is.defined).toBeDefined())
+      .it('is.false()', () => expect(is.false).toBeDefined())
+      .it('is.function()', () => expect(is.function).toBeDefined())
+      .it('is.instance()', () => expect(is.instance).toBeDefined())
+      .it('is.key()', () => expect(is.key).toBeDefined())
+      .it('is.null()', () => expect(is.null).toBeDefined())
+      .it('is.number()', () => expect(is.number).toBeDefined())
+      .it('is.numberBetween()', () => expect(is.numberBetween).toBeDefined())
+      .it('is.numberObject()', () => expect(is.numberObject).toBeDefined())
+      .it('is.numberType()', () => expect(is.numberType).toBeDefined())
+      .it('is.object()', () => expect(is.object).toBeDefined())
+      .it('is.objectKey()', () => expect(is.objectKey).toBeDefined())
+      .it('is.objectKeyIn()', () => expect(is.objectKeyIn).toBeDefined())
+      .it('is.objectKeys()', () => expect(is.objectKeys).toBeDefined())
+      .it('is.primitive()', () => expect(is.primitive).toBeDefined())
+      .it('is.regexp()', () => expect(is.regexp).toBeDefined())
+      .it('is.string()', () => expect(is.string).toBeDefined())
+      .it('is.stringLength()', () => expect(is.stringLength).toBeDefined())
+      .it('is.stringObject()', () => expect(is.stringObject).toBeDefined())
+      .it('is.stringType()', () => expect(is.stringType).toBeDefined())
+      .it('is.symbol()', () => expect(is.symbol).toBeDefined())
+      .it('is.true()', () => expect(is.true).toBeDefined())
+      .it('is.type()', () => expect(is.type).toBeDefined())
+      .it('is.undefined()', () => expect(is.undefined).toBeDefined());
    });
 });
diff --git a/src/is/type/is-array.type.ts b/src/is/type/is-array.type.ts
deleted file mode 100644
index 54483d32..00000000
--- a/src/is/type/is-array.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsArray = <Type = any>(value: any, callback?: ResultCallback) => value is Array<Type>;
diff --git a/src/is/type/is-big-int.type.ts b/src/is/type/is-big-int.type.ts
deleted file mode 100644
index 8bf35b21..00000000
--- a/src/is/type/is-big-int.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsBigInt = (value: any, callback?: ResultCallback) => value is bigint;
diff --git a/src/is/type/is-boolean-object.type.ts b/src/is/type/is-boolean-object.type.ts
deleted file mode 100644
index 1955c1b1..00000000
--- a/src/is/type/is-boolean-object.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsBooleanObject = (value: any, callback?: ResultCallback) => value is Boolean;
diff --git a/src/is/type/is-boolean-type.type.ts b/src/is/type/is-boolean-type.type.ts
deleted file mode 100644
index 66b74f80..00000000
--- a/src/is/type/is-boolean-type.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsBooleanType = (value: any, callback?: ResultCallback) => value is boolean;
diff --git a/src/is/type/is-boolean.type.ts b/src/is/type/is-boolean.type.ts
deleted file mode 100644
index 1a7dc6fb..00000000
--- a/src/is/type/is-boolean.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsBoolean = (value: any, callback?: ResultCallback) => value is boolean;
diff --git a/src/is/type/is-class.type.ts b/src/is/type/is-class.type.ts
deleted file mode 100644
index ae82326f..00000000
--- a/src/is/type/is-class.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsClass = <Class = Function>(value: any, callback?: ResultCallback) => value is Class;
diff --git a/src/is/type/is-defined.type.ts b/src/is/type/is-defined.type.ts
deleted file mode 100644
index 6b180933..00000000
--- a/src/is/type/is-defined.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Defined } from '../../type/defined.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsDefined = <Type>(value: Type, callback?: ResultCallback) => value is Defined<Type>;
diff --git a/src/is/type/is-function.type.ts b/src/is/type/is-function.type.ts
deleted file mode 100644
index 4e6db5b2..00000000
--- a/src/is/type/is-function.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Func } from '../../type/func.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsFunction = (value: any, callback?: ResultCallback) => value is Func;
diff --git a/src/is/type/is-instance.type.ts b/src/is/type/is-instance.type.ts
deleted file mode 100644
index 4d7bf6e5..00000000
--- a/src/is/type/is-instance.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Constructor } from '../../type/constructor.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsInstance = <Obj>(value: any, constructor: Constructor<Obj>, callback?: ResultCallback) => value is Obj;
diff --git a/src/is/type/is-key.type.ts b/src/is/type/is-key.type.ts
deleted file mode 100644
index 98fa4ded..00000000
--- a/src/is/type/is-key.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Key } from '../../type/key.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsKey = (value: any, callback?: ResultCallback) => value is Key;
diff --git a/src/is/type/is-null.type.ts b/src/is/type/is-null.type.ts
deleted file mode 100644
index dc464b0b..00000000
--- a/src/is/type/is-null.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsNull = (value: any, callback?: ResultCallback) => value is null;
diff --git a/src/is/type/is-number-object.type.ts b/src/is/type/is-number-object.type.ts
deleted file mode 100644
index 9d4f7dd6..00000000
--- a/src/is/type/is-number-object.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsNumberObject = (value: any, callback?: ResultCallback) => value is Number;
diff --git a/src/is/type/is-number-type.type.ts b/src/is/type/is-number-type.type.ts
deleted file mode 100644
index ed9df0db..00000000
--- a/src/is/type/is-number-type.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsNumberType = (value: any, callback?: ResultCallback) => value is number;
diff --git a/src/is/type/is-number.type.ts b/src/is/type/is-number.type.ts
deleted file mode 100644
index d959f5b8..00000000
--- a/src/is/type/is-number.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsNumber = (value: any, callback?: ResultCallback) => value is number;
diff --git a/src/is/type/is-object-key-in.type.ts b/src/is/type/is-object-key-in.type.ts
deleted file mode 100644
index 98969b13..00000000
--- a/src/is/type/is-object-key-in.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Key } from '../../type/key.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsObjectKeyIn = <Type = object>(value: any, key: Key | Key[], callback?: ResultCallback) => value is Type;
diff --git a/src/is/type/is-object-key.type.ts b/src/is/type/is-object-key.type.ts
deleted file mode 100644
index d01faa2e..00000000
--- a/src/is/type/is-object-key.type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Key } from '../../type/key.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsObjectKey = <Type = object>(value: any, key: Key | Key[], callback?: ResultCallback) => value is Type;
diff --git a/src/is/type/is-object-keys.type.ts b/src/is/type/is-object-keys.type.ts
deleted file mode 100644
index cb6bf8c9..00000000
--- a/src/is/type/is-object-keys.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { Key } from '../../type/key.type';
-export type IsObjectKeys = <Type = object>(value: any, ...keys: (Key | Array<Key>)[]) => value is Type;
diff --git a/src/is/type/is-object.type.ts b/src/is/type/is-object.type.ts
deleted file mode 100644
index 678d397a..00000000
--- a/src/is/type/is-object.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsObject = <Obj = object>(value: any, callback?: ResultCallback) => value is Obj;
diff --git a/src/is/type/is-primitive.type.ts b/src/is/type/is-primitive.type.ts
deleted file mode 100644
index f0aa4033..00000000
--- a/src/is/type/is-primitive.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { Primitive } from '../../type/primitive.type';
-import { Primitives } from '../../type/primitives.type';
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsPrimitive = <T extends Primitive>(value: any, type: Primitives, callback?: ResultCallback) => value is T;
diff --git a/src/is/type/is-string-object.type.ts b/src/is/type/is-string-object.type.ts
deleted file mode 100644
index 0b65411f..00000000
--- a/src/is/type/is-string-object.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsStringObject = (value: any, callback?: ResultCallback) => value is String;
diff --git a/src/is/type/is-string-type.type.ts b/src/is/type/is-string-type.type.ts
deleted file mode 100644
index bf8b4e4e..00000000
--- a/src/is/type/is-string-type.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsStringType = (value: any, callback?: ResultCallback) => value is string;
diff --git a/src/is/type/is-string.type.ts b/src/is/type/is-string.type.ts
deleted file mode 100644
index 03876e5b..00000000
--- a/src/is/type/is-string.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsString = (value: any, callback?: ResultCallback) => value is string;
diff --git a/src/is/type/is-symbol.type.ts b/src/is/type/is-symbol.type.ts
deleted file mode 100644
index a3466e95..00000000
--- a/src/is/type/is-symbol.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsSymbol = (value: any, callback?: ResultCallback) => value is symbol;
diff --git a/src/is/type/is-type.type.ts b/src/is/type/is-type.type.ts
deleted file mode 100644
index b62b760d..00000000
--- a/src/is/type/is-type.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-import { Type } from '../../type/type.type';
-import { Types } from '../../type/types.type';
-export type IsType = <T extends Type>(value: any, type: Types<T>, callback?: ResultCallback) => value is T;
diff --git a/src/is/type/is-undefined.type.ts b/src/is/type/is-undefined.type.ts
deleted file mode 100644
index e78d5a70..00000000
--- a/src/is/type/is-undefined.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { ResultCallback } from '../../type/result-callback.type';
-export type IsUndefined = (value: any, callback?: ResultCallback) => value is undefined;
diff --git a/src/lib/bigint-object.class.ts b/src/lib/bigint-object.class.ts
deleted file mode 100644
index 4abf6ebb..00000000
--- a/src/lib/bigint-object.class.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { PrimitiveObject } from './primitive-object.class';
-
-export class BigIntObject {
-  static set set(value: any) {
-    PrimitiveObject.bigint = BigInt(value);
-  }
-  static get get(): BigInt {
-    return PrimitiveObject.bigint;
-  }
-}
diff --git a/src/lib/boolean-object.class.ts b/src/lib/boolean-object.class.ts
deleted file mode 100644
index 632f34b7..00000000
--- a/src/lib/boolean-object.class.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { PrimitiveObject } from './primitive-object.class';
-
-export class BooleanObject {
-  /**
-   * `false` when empty, 0, null, '', false
-   * `true` when 'true', 'false', 'Su Lin whatever', [], {}, true
-   */
-  static set set(value: any) {
-    PrimitiveObject.boolean = new Boolean(value);
-  }
-  static get get(): Boolean {
-    return PrimitiveObject.boolean;
-  }
-}
diff --git a/src/lib/index.ts b/src/lib/index.ts
new file mode 100644
index 00000000..a81a4d9a
--- /dev/null
+++ b/src/lib/index.ts
@@ -0,0 +1,5 @@
+// Object.
+export { type } from './type.object';
+// Function.
+export { resultCallback } from './result-callback.func';
+export { typeOf } from './type-of.func';
diff --git a/src/lib/number-object.class.ts b/src/lib/number-object.class.ts
deleted file mode 100644
index 30f19bdb..00000000
--- a/src/lib/number-object.class.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { PrimitiveObject } from './primitive-object.class';
-
-export class NumberObject {
-  static set set(value: any) {
-    PrimitiveObject.number = new Number(value);
-  }
-  static get get(): Number {
-    return PrimitiveObject.number;
-  }
-}
diff --git a/src/lib/primitive-object.class.ts b/src/lib/primitive-object.class.ts
deleted file mode 100644
index 6aeea8f5..00000000
--- a/src/lib/primitive-object.class.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-export class PrimitiveObject  {
-  static bigint: BigInt;
-  static boolean: Boolean;
-  static number: Number;
-  static string: String;
-  static symbol: Symbol;
-}
diff --git a/src/lib/result-callback.func.ts b/src/lib/result-callback.func.ts
index 97c1c602..278a6081 100644
--- a/src/lib/result-callback.func.ts
+++ b/src/lib/result-callback.func.ts
@@ -1,7 +1,6 @@
-import { ResultCallback } from '../type/result-callback.type';
 /**
- * Default function to handle `callback`.
- * @param result A `boolean` type value from the result of the check.
- * @returns result A `boolean` type result from the check.
+ * Default function to handle `callback` of functions.
+ * @param result A value of `boolean` type of the result of the check.
+ * @returns The return value is a `boolean` of the result of the check.
  */
-export const resultCallback: ResultCallback = (result: boolean): boolean => result;
+export const resultCallback = (result: boolean): boolean => result;
diff --git a/src/lib/string-object.class.ts b/src/lib/string-object.class.ts
deleted file mode 100644
index 88c21ee3..00000000
--- a/src/lib/string-object.class.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { PrimitiveObject } from './primitive-object.class';
-
-export class StringObject {
-  /**
-   * Create a new `String` instance.
-   */
-  static set set(value: any) {
-    PrimitiveObject.string = new String(value);
-  }
-  /**
-   * Get instance.
-   */
-   static get get(): String {
-    return PrimitiveObject.string;
-  }
-}
diff --git a/src/lib/symbol-object.class.ts b/src/lib/symbol-object.class.ts
deleted file mode 100644
index a45e96c3..00000000
--- a/src/lib/symbol-object.class.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { PrimitiveObject } from './primitive-object.class';
-
-export class SymbolObject {
-  static set set(value: string | number | undefined) {
-    PrimitiveObject.symbol = Symbol(value);
-  }
-  static get get(): Symbol {
-    return PrimitiveObject.symbol;
-  }
-}
diff --git a/src/lib/type-of.func.ts b/src/lib/type-of.func.ts
index 3467009b..4c0d7818 100644
--- a/src/lib/type-of.func.ts
+++ b/src/lib/type-of.func.ts
@@ -1,7 +1,8 @@
 /**
- * https://javascript.plainenglish.io/the-best-way-to-type-check-in-vanilla-js-55197b4f45ec
- * @param value Any value to check its Object.prototype type.
+ * Gets the specific object class type of any value.
+ * @param value Any value to check its object class type.
  * @author https://javascript.plainenglish.io/the-best-way-to-type-check-in-vanilla-js-55197b4f45ec
- * @returns string.
+ * @returns The return value is a `string` of the object class name.
  */
-export const typeOf = (value: any): string => Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
+export const typeOf = (value: any): string =>
+  Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
diff --git a/src/lib/type.object.ts b/src/lib/type.object.ts
new file mode 100644
index 00000000..1e177e20
--- /dev/null
+++ b/src/lib/type.object.ts
@@ -0,0 +1,23 @@
+// Object.
+import { are } from '../are/lib/are.object';
+import { guard } from '../guard/lib/guard.object';
+import { is } from '../is/lib/is.object';
+/**
+ * The `object` consists of `are`, `is` and `guard` objects.
+ */
+export const type = Object.freeze({
+  /**
+   * The object consists of `are` functions.
+   */
+  are,
+
+  /**
+   * The object consists of `is` functions.
+   */
+  is,
+
+  /**
+   * The `object` consists of `guard` functions.
+   */
+  guard
+});
diff --git a/src/public-api.ts b/src/public-api.ts
index 5895d95a..59d037b8 100644
--- a/src/public-api.ts
+++ b/src/public-api.ts
@@ -1,72 +1,101 @@
 /*
- * Public API Surface of type
+ * Public API Surface of type.
+ */
+/*
+ * Main.
  */
-export { typeOf } from './lib/type-of.func';
-
-// `guard` object.
-export { guard } from './guard';
-// `guard` functions.
 export {
-  guardArray,
-  guardBigInt,
-  guardBoolean,
-  guardClass,
-  guardDefined,
-  guardFunction,
-  guardInstance,
-  guardKey,
-  guardNull,
-  guardNumber,
-  guardObject,
-  guardObjectKey,
-  guardObjectKeys,
-  guardPrimitive,
-  guardString,
-  guardSymbol,
-  guardType,
-  guardUndefined,
-} from './guard';
+  // Object.
+  type, // From the 5.0.0 version
 
-// `are` object and functions.
-export { are, areString } from './are';
+  // Function.
+  typeOf
+} from './lib';
+
+/*
+ * Recognize.
+ */
+export {
+  recognizeValue // From the 5.0.0 version
+} from './recognize';
 
-// `is` object.
-export { is } from './is';
+/*
+ * Are.
+ */
+export {
+  // Object.
+  are,
 
-// `isNot` object.
-export { isNot } from './is/not';
+  // Function.
+  areBigInt,
+  areBoolean,
+  areDate,
+  areDefined,
+  areFalse,
+  areNull,
+  areNumber,
+  areRegExp,
+  areString,
+  areSymbol,
+  areTrue,
+  areUndefined,
+} from './are';
 
-// `is` functions.
+/*
+ * Is.
+ */
 export {
+  // Object.
+  is,
+
+  // Function.
   isArray,
   isBigInt,
   isBoolean,
   isBooleanObject,
   isBooleanType,
   isClass,
+  isDate, // From the 4.2.0 version.
   isDefined,
+  isFalse, // From the 4.2.0 version.
   isFunction,
   isInstance,
   isKey,
   isNull,
   isNumber,
+  isNumberBetween, // From the 4.2.0 version.
   isNumberObject,
   isNumberType,
   isObject,
   isObjectKey,
   isObjectKeyIn,
   isObjectKeys,
+  isObjectKeysIn, // From the 5.0.0 version
+  isObjectSomeKeys, // From the 5.0.0 version
+  isParam,
   isPrimitive,
+  isRegExp, // From the 4.2.0 version.
   isString,
+  isStringIncludes, // From the 5.0.0 version
+  isStringIncludesSome, // From the 5.0.0 version
+  isStringLength, // From the 4.2.0 version.
+  isStringLengthBetween, // From the 5.0.0 version
   isStringObject,
   isStringType,
   isSymbol,
+  isTrue, // From the 4.2.0 version.
   isType,
   isUndefined,
 } from './is';
 
-// `isNot` functions.
+/*
+ * isNot.
+ */
 export {
+  // Object.
+  isNot,
+
+  // Function.
   isNotBoolean,
   isNotDefined,
   isNotFunction,
@@ -76,21 +105,71 @@ export {
   isNotUndefined,
 } from './is/not';
 
-// Types.
+/*
+ * Guard.
+ */
+export {
+  // Object.
+  guard,
+
+  // Function.
+  guardArray,
+  guardBigInt,
+  guardBoolean,
+  guardClass,
+  guardDate, // From the 5.0.0 version
+  guardDefined,
+  guardFalse, // From the 5.0.0 version
+  guardFunction,
+  guardInstance,
+  guardKey,
+  guardNull,
+  guardNumber,
+  guardNumberBetween, // From the 5.0.0 version
+  guardObject,
+  guardObjectKey,
+  guardObjectKeyIn, // From the 5.0.0 version
+  guardObjectKeys,
+  guardObjectKeysIn, // From the 5.0.0 version
+  guardObjectSomeKeys, // From the 5.0.0 version
+  guardPrimitive,
+  guardRegExp, // From the 5.0.0 version
+  guardString,
+  guardStringIncludes, // From the 5.0.0 version
+  guardStringIncludesSome, // From the 5.0.0 version
+  guardStringLength, // From the 5.0.0 version
+  guardStringLengthBetween, // From the 5.0.0 version
+  guardSymbol,
+  guardTrue, // From the 5.0.0 version
+  guardType,
+  guardUndefined,
+} from './guard';
+
+/*
+ * Interface.
+ */
 export {
-  AnyBoolean,
-  AnyNumber,
-  AnyString,
-  Constructor,
-  CycleHook,
-  Defined,
-  Func,
-  Key,
-  Never,
-  NotUndefined,
-  Primitive,
-  Primitives,
-  ResultCallback,
-  Type,
-  Types,
-} from './type';
+  MinMax  // From the 5.0.0 version
+} from './interface';
+
+/*
+ * Type.
+ */
+export { AnyBoolean } from './type/any-boolean.type';
+export { AnyNumber } from './type/any-number.type';
+export { AnyString } from './type/any-string.type';
+export { CallbackPayload } from './type/callback-payload.type';
+export { Constructor } from './type/constructor.type';
+export { Defined } from './type/defined.type';
+export { ForEachCallback } from './type/foreach-callback.type';
+export { GenericObject } from './type/generic-object.type';
+export { Never } from './type/never.type';
+export { NotUndefined } from './type/not-undefined.type';
+export { NumberBetween } from './type/number-between.type';
+export { Primitive } from './type/primitive.type';
+export { Primitives } from './type/primitives.type';
+export { ResultCallback } from './type/result-callback.type';
+export { StringOfLength } from './type/string-of-length.type';
+export { Type } from './type/type.type';
+export { Types } from './type/types.type';
+export { Undefined } from './type/undefined.type';
diff --git a/src/recognize/index.ts b/src/recognize/index.ts
new file mode 100644
index 00000000..0befa95e
--- /dev/null
+++ b/src/recognize/index.ts
@@ -0,0 +1 @@
+export { recognizeValue } from './src/recognize-value.func';
diff --git a/src/recognize/src/recognize-instances.const.ts b/src/recognize/src/recognize-instances.const.ts
new file mode 100644
index 00000000..a53ebd42
--- /dev/null
+++ b/src/recognize/src/recognize-instances.const.ts
@@ -0,0 +1,37 @@
+/**
+ * An `Array` of default objects to check by using the `instanceof` operator.
+ */
+export const RECOGNIZE_INSTANCES = [
+  Array,
+  ArrayBuffer,
+  Boolean,
+  DataView,
+  Date,
+  Error,
+  EvalError,
+  Float32Array,
+  Float64Array,
+  Function,
+  Int16Array,
+  Int32Array,
+  Int8Array,
+  Map,
+  Number,
+  Object,
+  Promise,
+  RangeError,
+  ReferenceError,
+  RegExp,
+  Set,
+  Storage,
+  String,
+  SyntaxError,
+  TypeError,
+  URIError,
+  Uint16Array,
+  Uint32Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  WeakMap,
+  WeakSet
+];
diff --git a/src/recognize/src/recognize-value.func.ts b/src/recognize/src/recognize-value.func.ts
new file mode 100644
index 00000000..9fdef1d4
--- /dev/null
+++ b/src/recognize/src/recognize-value.func.ts
@@ -0,0 +1,51 @@
+// Object.
+import { is } from '../../is/lib/is.object';
+// Function.
+import { typeOf } from '../../lib/type-of.func';
+// Type.
+import { OfRecognized } from '../type/of-recognized.type';
+// Const.
+import { RECOGNIZE_INSTANCES } from './recognize-instances.const';
+/**
+ * Gets recognized types and instances of given `value`.
+ * @param value The value of any type to recognize.
+ * @param onlyTrue Determines whether or not show only recognized as `true`.
+ * @param instances An optional array of objects to check by using `instanceof` operator.
+ * @returns The return value is an object of types and instances recognized as `true` or all even those recognized as `false`.
+ */
+export const recognizeValue = (
+  value: any,
+  onlyTrue: boolean = true,
+  instances: any[] = []
+): OfRecognized => {
+  // Recognize types.
+  const ofRecognized: OfRecognized = {
+    'Array.isArray': Array.isArray(value),
+    isClass: is.class(value),
+    isFunction: is.function(value),
+    'Number.isInteger': Number.isInteger(value),
+    'Number.isFinite': Number.isFinite(value),
+    'Number.isNaN': Number.isNaN(value),
+    'Number.isSafeInteger': Number.isSafeInteger(value),
+    typeOf: typeOf(value),
+    typeof: typeof value,
+  };
+
+  try { Object.assign(ofRecognized, { isFinite: isFinite(value) }); } catch (e) {}
+  try { Object.assign(ofRecognized, { isNaN: isNaN(value) }); } catch (e) {}
+
+  // Recognize instances.
+  RECOGNIZE_INSTANCES.concat(instances as any).forEach((instance) => (
+    Object.assign(ofRecognized, { [instance.name]: value instanceof instance })
+  ));
+
+  // If only true remove false.
+  if (is.true(onlyTrue)) {
+    Object.keys(ofRecognized).filter((type: string) =>
+      is.false(ofRecognized[type as keyof OfRecognized])
+        ? delete ofRecognized[type as keyof OfRecognized]
+        : true
+    );
+  }
+  return ofRecognized;
+};
diff --git a/src/recognize/test/recognize-value.spec.ts b/src/recognize/test/recognize-value.spec.ts
new file mode 100644
index 00000000..451467ba
--- /dev/null
+++ b/src/recognize/test/recognize-value.spec.ts
@@ -0,0 +1,360 @@
+// Testing.
+import { Testing } from '@angular-package/testing';
+import { tests } from '../../execute-tests';
+// Function.
+import { recognizeValue } from '../src/recognize-value.func';
+/*
+  Initialize testing.
+ */
+const testing = new Testing(
+  tests.recognize.recognizeValue.describe,
+  tests.recognize.recognizeValue.it
+);
+
+class CustomClass {}
+const customClass = new CustomClass();
+
+const firstName = 'Artemis';
+
+
+/*
+  Tests.
+*/
+testing.describe(recognizeValue.name, () =>
+  testing
+    .toEqual(`NaN`, recognizeValue(NaN), {
+      'Number.isNaN': true,
+      isNaN: true,
+      typeOf: 'number',
+      typeof: 'number',
+    })
+
+    .toEqual(`Number.NaN`, recognizeValue(Number.NaN), {
+      'Number.isNaN': true,
+      isNaN: true,
+      typeOf: 'number',
+      typeof: 'number',
+    })
+
+    .toEqual(`0 / 0`, recognizeValue(0 / 0), {
+      'Number.isNaN': true,
+      isNaN: true,
+      typeOf: 'number',
+      typeof: 'number',
+    })
+
+    .toEqual(`true`, recognizeValue(true), {
+      isFinite: true,
+      typeOf: 'boolean',
+      typeof: 'boolean',
+    })
+
+    .toEqual(`'NaN'`, recognizeValue('NaN'), {
+      isNaN: true,
+      typeOf: 'string',
+      typeof: 'string',
+    })
+
+    .toEqual(`string = 2.0`, recognizeValue('2.0'), {
+      isFinite: true,
+      typeOf: 'string',
+      typeof: 'string',
+    })
+
+    .toEqual(`new String(firstName)`, recognizeValue(new String(firstName)), {
+      typeOf: 'string',
+      typeof: 'object',
+      isNaN: true,
+      Object: true,
+      String: true,
+    })
+
+    .toEqual(`CustomClass`, recognizeValue(customClass, true, [CustomClass]), {
+      CustomClass: true,
+      Object: true,
+      isNaN: true,
+      typeOf: 'object',
+      typeof: 'object',
+    })
+
+    .toEqual(`CustomClass`, recognizeValue(CustomClass, true, [CustomClass]), {
+      Function: true,
+      Object: true,
+      isClass: true,
+      isNaN: true,
+      typeOf: 'function',
+      typeof: 'function',
+    })
+
+    .toEqual(`new Array()`, recognizeValue(new Array()), {
+      Array: true,
+      Object: true,
+      'Array.isArray': true,
+      isFinite: true,
+      typeOf: 'array',
+      typeof: 'object',
+    })
+
+    .toEqual(`Array`, recognizeValue(Array), {
+      Function: true,
+      Object: true,
+      isFunction: true,
+      isNaN: true,
+      typeOf: 'function',
+      typeof: 'function',
+    })
+
+    .toEqual(`new ArrayBuffer(50)`, recognizeValue(new ArrayBuffer(50)), {
+      ArrayBuffer: true,
+      Object: true,
+      isNaN: true,
+      typeOf: 'arraybuffer',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Boolean()`, recognizeValue(new Boolean()), {
+      Boolean: true,
+      Object: true,
+      isFinite: true,
+      typeOf: 'boolean',
+      typeof: 'object',
+    })
+
+    .toEqual(
+      `new DataView(new ArrayBuffer(16))`,
+      recognizeValue(new DataView(new ArrayBuffer(16))), {
+        DataView: true,
+        Object: true,
+        isNaN: true,
+        typeOf: 'dataview',
+        typeof: 'object'
+      }
+    )
+
+    .toEqual(`new Date()`, recognizeValue(new Date()), {
+      Date: true,
+      Object: true,
+      isFinite: true,
+      typeOf: 'date',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Error()`, recognizeValue(new Error()), {
+      Error: true,
+      Object: true,
+      isNaN: true,
+      typeOf: 'error',
+      typeof: 'object',
+    })
+
+    .toEqual(`new EvalError()`, recognizeValue(new EvalError()), {
+      Error: true,
+      EvalError: true,
+      Object: true,
+      isNaN: true,
+      typeOf: 'error',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Int16Array()`, recognizeValue(new Int16Array()), {
+      Int16Array: true,
+      Object: true,
+      isFinite: true,
+      typeOf: 'int16array',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Int32Array()`, recognizeValue(new Int32Array()), {
+      Int32Array: true,
+      Object: true,
+      isFinite: true,
+      typeOf: 'int32array',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Int8Array()`, recognizeValue(new Int8Array()), {
+      Int8Array: true,
+      Object: true,
+      isFinite: true,
+      typeOf: 'int8array',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Map()`, recognizeValue(new Map()), {
+      Map: true,
+      Object: true,
+      isNaN: true,
+      typeOf: 'map',
+      typeof: 'object',
+    })
+
+    // .toEqual(`new Promise((resolve, reject) => {
+    //   setTimeout(() => {
+    //     resolve('foo');
+    //   }, 300);
+    // })`, recognizeValue(new Promise((resolve, reject) => {
+    //   setTimeout(() => {
+    //     resolve('foo');
+    //   }, 300);
+    // })), {Promise: true, Object: true, typeOf: 'promise', typeof: 'object'})
+
+    .toEqual(`new RangeError()`, recognizeValue(new RangeError()), {
+      Error: true,
+      Object: true,
+      RangeError: true,
+      isNaN: true,
+      typeOf: 'error',
+      typeof: 'object',
+    })
+
+    .toEqual(`new ReferenceError()`, recognizeValue(new ReferenceError()), {
+      Error: true,
+      ReferenceError: true,
+      Object: true,
+      isNaN: true,
+      typeOf: 'error',
+      typeof: 'object',
+    })
+
+    .toEqual(`new RegExp(/[^]/g)`, recognizeValue(new RegExp(/[^]/g)), {
+      typeOf: 'regexp',
+      typeof: 'object',
+      isNaN: true,
+      Object: true,
+      RegExp: true,
+    })
+
+    .toEqual(`new Set()`, recognizeValue(new Set()), {
+      Object: true,
+      Set: true,
+      isNaN: true,
+      typeOf: 'set',
+      typeof: 'object',
+    })
+
+    .toEqual(`new SyntaxError()`, recognizeValue(new SyntaxError()), {
+      Error: true,
+      SyntaxError: true,
+      Object: true,
+      isNaN: true,
+      typeOf: 'error',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Float32Array()`, recognizeValue(new Float32Array()), {
+      Float32Array: true,
+      Object: true,
+      isFinite: true,
+      typeOf: 'float32array',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Float64Array()`, recognizeValue(new Float64Array()), {
+      Float64Array: true,
+      Object: true,
+      isFinite: true,
+      typeOf: 'float64array',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Function()`, recognizeValue(new Function()), {
+      Function: true,
+      Object: true,
+      isFunction: true,
+      isNaN: true,
+      typeOf: 'function',
+      typeof: 'function',
+    })
+
+    .toEqual(`new Number(5)`, recognizeValue(new Number(5)), {
+      Number: true,
+      Object: true,
+      isFinite: true,
+      typeOf: 'number',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Object()`, recognizeValue(new Object()), {
+      Object: true,
+      isNaN: true,
+      typeOf: 'object',
+      typeof: 'object',
+    })
+
+    .toEqual(`new String()`, recognizeValue(new String()), {
+      Object: true,
+      String: true,
+      isFinite: true,
+      typeOf: 'string',
+      typeof: 'object',
+    })
+
+    .toEqual(`new TypeError()`, recognizeValue(new TypeError()), {
+      Error: true,
+      Object: true,
+      TypeError: true,
+      isNaN: true,
+      typeOf: 'error',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Uint16Array()`, recognizeValue(new Uint16Array()), {
+      Object: true,
+      Uint16Array: true,
+      isFinite: true,
+      typeOf: 'uint16array',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Uint32Array()`, recognizeValue(new Uint32Array()), {
+      Object: true,
+      Uint32Array: true,
+      isFinite: true,
+      typeOf: 'uint32array',
+      typeof: 'object',
+    })
+
+    .toEqual(`new Uint8Array()`, recognizeValue(new Uint8Array()), {
+      Object: true,
+      Uint8Array: true,
+      isFinite: true,
+      typeOf: 'uint8array',
+      typeof: 'object',
+    })
+
+    .toEqual(
+      `new Uint8ClampedArray()`,
+      recognizeValue(new Uint8ClampedArray()), {
+        Object: true,
+        Uint8ClampedArray: true,
+        isFinite: true,
+        typeOf: 'uint8clampedarray',
+        typeof: 'object',
+      }
+    )
+
+    .toEqual(`new URIError()`, recognizeValue(new URIError()), {
+      Error: true,
+      Object: true,
+      URIError: true,
+      isNaN: true,
+      typeOf: 'error',
+      typeof: 'object',
+    })
+
+    .toEqual(`new WeakMap()`, recognizeValue(new WeakMap()), {
+      Object: true,
+      WeakMap: true,
+      isNaN: true,
+      typeOf: 'weakmap',
+      typeof: 'object',
+    })
+
+    .toEqual(`new WeakSet()`, recognizeValue(new WeakSet()), {
+      Object: true,
+      WeakSet: true,
+      isNaN: true,
+      typeOf: 'weakset',
+      typeof: 'object',
+    })
+);
diff --git a/src/recognize/type/of-recognized.type.ts b/src/recognize/type/of-recognized.type.ts
new file mode 100644
index 00000000..1550ed88
--- /dev/null
+++ b/src/recognize/type/of-recognized.type.ts
@@ -0,0 +1,59 @@
+export interface OfRecognized {
+  // Proxy?: boolean;
+  Array?: boolean;
+  ArrayBuffer?: boolean;
+  Boolean?: boolean;
+  DataView?: boolean;
+  Date?: boolean;
+  Error?: boolean;
+  EvalError?: boolean;
+  Float32Array?: boolean;
+  Float64Array?: boolean;
+  Function?: boolean;
+  Int16Array?: boolean;
+  Int32Array?: boolean;
+  Int8Array?: boolean;
+  Map?: boolean;
+  Number?: boolean;
+  Object?: boolean;
+  Promise?: boolean;
+  RangeError?: boolean;
+  ReferenceError?: boolean;
+  RegExp?: boolean;
+  Set?: boolean;
+  SharedArrayBuffer?: boolean;
+  Storage?: boolean;
+  String?: boolean;
+  Symbol?: boolean;
+  SyntaxError?: boolean;
+  TypeError?: boolean;
+  URIError?: boolean;
+  Uint16Array?: boolean;
+  Uint32Array?: boolean;
+  Uint8Array?: boolean;
+  Uint8ClampedArray?: boolean;
+  WeakMap?: boolean;
+  WeakSet?: boolean;
+  // Array.isArray()
+  'Array.isArray'?: boolean;
+  // isClass()
+  isClass?: boolean;
+  // isFunction()
+  isFunction?: boolean;
+  // isFinite()
+  isFinite?: boolean;
+  // isInteger()
+  'Number.isInteger'?: boolean;
+  // isNaN()
+  isNaN?: boolean;
+  // Number.isNaN()
+  'Number.isNaN'?: boolean;
+  // Number.isFinite()
+  'Number.isFinite'?: boolean;
+  // typeOf()
+  typeOf?: string;
+  // operator typeof
+  typeof?: string;
+
+  [index: string]: boolean | string | undefined;
+}
diff --git a/src/test.ts b/src/test.ts
index 303b32a2..a7d1b428 100644
--- a/src/test.ts
+++ b/src/test.ts
@@ -18,7 +18,9 @@ declare const require: {
 // First, initialize the Angular testing environment.
 getTestBed().initTestEnvironment(
   BrowserDynamicTestingModule,
-  platformBrowserDynamicTesting()
+  platformBrowserDynamicTesting(), {
+    teardown: { destroyAfterEach: false }
+}
 );
 // Then we find all the tests.
 const context = require.context('./', true, /\.spec\.ts$/);
diff --git a/src/test/bigint-object.spec.ts b/src/test/bigint-object.spec.ts
deleted file mode 100644
index ed60c757..00000000
--- a/src/test/bigint-object.spec.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { BIGINT, BIGINT_EXPECTATION, BIGINT_INSTANCE } from '../testing/src/big-int.const';
-import { BigIntObject } from '../lib/bigint-object.class';
-
-
-describe(`BigIntObject`, () => {
-  // Defined.
-  it('is DEFINED', () => expect(BigIntObject).toBeDefined());
-
-  // Checks ...
-  describe(`checks`, () => {
-
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`bigint`, () => {
-        it(`${BIGINT}`, () => {
-          BigIntObject.set = BIGINT;
-          expect(BigIntObject.get).toEqual(BIGINT);
-        });
-        it(`${BIGINT_EXPECTATION}`, () => {
-          BigIntObject.set = BIGINT_INSTANCE;
-          expect(BigIntObject.get).toEqual(BIGINT_INSTANCE);
-        });
-      });
-    });
-  });
-});
diff --git a/src/test/boolean-object.spec.ts b/src/test/boolean-object.spec.ts
deleted file mode 100644
index a8dc6f28..00000000
--- a/src/test/boolean-object.spec.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { TRUE, TRUE_EXPECTATION, TRUE_INSTANCE, FALSE, FALSE_INSTANCE, FALSE_EXPECTATION } from '../testing/src/boolean.const';
-import { BooleanObject } from '../lib/boolean-object.class';
-
-
-describe(`BooleanObject`, () => {
-  // Defined.
-  it('is DEFINED', () => expect(BooleanObject).toBeDefined());
-
-  // Checks ...
-  describe(`checks`, () => {
-
-    // ... primitives.
-    describe(`primitive`, () => {
-      // bigint
-      describe(`boolean`, () => {
-
-        it(`${TRUE}`, () => {
-          BooleanObject.set = TRUE;
-          expect(BooleanObject.get).not.toEqual(FALSE_INSTANCE);
-          expect(BooleanObject.get.valueOf()).toBeInstanceOf(Boolean);
-          expect(BooleanObject.get.valueOf()).toBeTruthy();
-          expect(BooleanObject.get.valueOf()).toBe(TRUE);
-        });
-
-        it(`${TRUE_EXPECTATION}`, () => {
-          BooleanObject.set = TRUE_INSTANCE;
-          expect(BooleanObject.get.valueOf()).toBeInstanceOf(Boolean);
-          expect(BooleanObject.get.valueOf()).toBeTrue();
-          expect(BooleanObject.get.valueOf()).toBeTruthy();
-          expect(BooleanObject.get.valueOf()).toBe(TRUE);
-        });
-
-        it(`${FALSE}`, () => {
-          BooleanObject.set = FALSE;
-          expect(BooleanObject.get).not.toEqual(TRUE_INSTANCE);
-          expect(BooleanObject.get.valueOf()).toBeInstanceOf(Boolean);
-          expect(BooleanObject.get.valueOf()).toBeFalse();
-          expect(BooleanObject.get.valueOf()).toBe(FALSE);
-        });
-
-        it(`${FALSE_EXPECTATION}`, () => {
-          BooleanObject.set = FALSE_INSTANCE;
-          expect(BooleanObject.get.valueOf().valueOf()).toBeInstanceOf(Boolean);
-          expect(BooleanObject.get.valueOf().valueOf()).toBeTrue();
-          expect(BooleanObject.get.valueOf().valueOf()).toBeTruthy();
-          expect(BooleanObject.get.valueOf().valueOf()).toBe(TRUE);
-        });
-      });
-    });
-  });
-});
diff --git a/src/test/number-object.spec.ts b/src/test/number-object.spec.ts
deleted file mode 100644
index f3884d3d..00000000
--- a/src/test/number-object.spec.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from '../testing/src/number.const';
-import { NumberObject } from '../lib/number-object.class';
-
-
-describe(`NumberObject`, () => {
-  // Defined.
-  it('is DEFINED', () => expect(NumberObject).toBeDefined());
-
-  // Checks ...
-  describe(`checks`, () => {
-
-    // ... primitives.
-    describe(`primitive`, () => {
-      // number
-      describe(`number`, () => {
-        NumberObject.set = NUMBER;
-        it(`${NUMBER}`, () => expect(NumberObject.get).toEqual(NUMBER));
-
-        NumberObject.set = NUMBER_INSTANCE;
-        it(`Number(${NUMBER})`, () => expect(NumberObject.get).toEqual(NUMBER_INSTANCE));
-
-        NumberObject.set = NUMBER_NEW_INSTANCE;
-        it(`new Number(${NUMBER})`, () => expect(NumberObject.get).toEqual(NUMBER_NEW_INSTANCE));
-      });
-    });
-  });
-});
diff --git a/src/test/string-object.spec.ts b/src/test/string-object.spec.ts
deleted file mode 100644
index be641a73..00000000
--- a/src/test/string-object.spec.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { StringObject } from '../lib/string-object.class';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../testing/src/string.const';
-
-
-describe(`StringObject`, () => {
-  // Defined.
-  it('is DEFINED', () => expect(StringObject).toBeDefined());
-
-  // Checks ...
-  describe(`checks`, () => {
-
-    // ... primitives.
-    describe(`primitive`, () => {
-      // string
-      describe(`string`, () => {
-        StringObject.set = STRING;
-        it(`${STRING}`, () => expect(StringObject.get).toEqual(STRING));
-
-        StringObject.set = STRING_INSTANCE;
-        it(`Number(${STRING})`, () => expect(StringObject.get).toEqual(STRING_INSTANCE));
-
-        StringObject.set = STRING_NEW_INSTANCE;
-        it(`new Number(${STRING})`, () => expect(StringObject.get).toEqual(STRING_NEW_INSTANCE));
-      });
-    });
-  });
-});
diff --git a/src/test/symbol-object.spec.ts b/src/test/symbol-object.spec.ts
deleted file mode 100644
index 0e25c55b..00000000
--- a/src/test/symbol-object.spec.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from '../testing/src/string.const';
-import { SymbolObject } from '../lib/symbol-object.class';
-import { SYMBOL_NUMBER } from '../testing/src/symbol.const';
-
-describe(`SymbolObject`, () => {
-  // Defined.
-  it('is DEFINED', () => expect(SymbolObject).toBeDefined());
-
-  // Checks ...
-  describe(`checks`, () => {
-
-    // ... primitives.
-    describe(`primitive`, () => {
-      // string
-      describe(`symbol`, () => {
-        SymbolObject.set = STRING;
-        it(`Symbol(${STRING})`, () => expect(SymbolObject.get).toBeDefined());
-      });
-    });
-  });
-});
diff --git a/src/testing/interface/accessor-descriptor.interface.ts b/src/testing/interface/accessor-descriptor.interface.ts
deleted file mode 100644
index 75a50151..00000000
--- a/src/testing/interface/accessor-descriptor.interface.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { CommonDescriptor } from './common-descriptor.interface';
-/**
- * Accessor descriptor with its unique `get` and `set` attributes and theirs generic `Value` type.
- */
-export interface AccessorDescriptor<Value> extends CommonDescriptor {
-  get: (() => Value) | undefined;
-  set: ((value: Value) => void) | undefined;
-}
diff --git a/src/testing/interface/common-descriptor.interface.ts b/src/testing/interface/common-descriptor.interface.ts
deleted file mode 100644
index bef51621..00000000
--- a/src/testing/interface/common-descriptor.interface.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-/**
- * Common `configurable` and `enumerable` of a `boolean` type attributes picked from default `PropertyDescriptor` for accessor and data
- * descriptor.
- * "If a descriptor has neither of `value`, `writable`, `get` and `set` keys, it is treated as a data descriptor. "
- */
-export interface CommonDescriptor extends Pick<PropertyDescriptor, 'configurable' | 'enumerable'> {}
diff --git a/src/testing/interface/data-descriptor.interface.ts b/src/testing/interface/data-descriptor.interface.ts
deleted file mode 100644
index 097a03bf..00000000
--- a/src/testing/interface/data-descriptor.interface.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { CommonDescriptor } from './common-descriptor.interface';
-/**
- * Data descriptor with its unique `writable`, `value` attributes, and a generic `Value` type for the `value`.
- */
-export interface DataDescriptor<Value> extends CommonDescriptor {
-  writable: boolean;
-  value: Value;
-}
diff --git a/src/testing/interface/index.ts b/src/testing/interface/index.ts
deleted file mode 100644
index 9379c8a0..00000000
--- a/src/testing/interface/index.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-// Interface.
-export { AccessorDescriptor } from './accessor-descriptor.interface';
-export { DataDescriptor } from './data-descriptor.interface';
-export { CommonDescriptor } from './common-descriptor.interface';
-export { ObjectOne } from './object-one.interface';
-export { ObjectTwo } from './object-two.interface';
diff --git a/src/testing/interface/object-one.interface.ts b/src/testing/interface/object-one.interface.ts
deleted file mode 100644
index 8b2f40f6..00000000
--- a/src/testing/interface/object-one.interface.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { NUMBER } from '../src/strict/number.const';
-import { STRING } from '../src/strict/string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from '../src/strict/symbol.const';
-
-export interface ObjectOne {
-  'key as string'?: boolean;
-  1030405027?: string;
-  5?: string;
-  [NUMBER]?: string;
-  [STRING]?: string;
-  [SYMBOL_NUMBER]?: string;
-  [SYMBOL_STRING]?: number;
-  x: number;
-}
diff --git a/src/testing/interface/object-two.interface.ts b/src/testing/interface/object-two.interface.ts
deleted file mode 100644
index de49b99c..00000000
--- a/src/testing/interface/object-two.interface.ts
+++ /dev/null
@@ -1 +0,0 @@
-export interface ObjectTwo { x: string; y: number; }
diff --git a/src/testing/interface/person.interface.ts b/src/testing/interface/person.interface.ts
deleted file mode 100644
index 42da7840..00000000
--- a/src/testing/interface/person.interface.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export interface Person {
-  firstName?: string;
-  surname?: string;
-  age?: number;
-  sex?: 'male' | 'female';
-}
diff --git a/src/testing/src/array.const.ts b/src/testing/src/array.const.ts
deleted file mode 100644
index 46641938..00000000
--- a/src/testing/src/array.const.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-// Constant.
-import { BIGINT, BIGINT_INSTANCE } from './big-int.const';
-import { Class } from './class.const';
-import { FALSE, TRUE, TRUE_INSTANCE, FALSE_INSTANCE } from './boolean.const';
-import { NULL } from './null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from './number.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from './string.const';
-import { UNDEFINED } from './undefined.const';
-import { notDefined } from './not-defined.const';
-
-// Arrays.
-// Array with `bigint`.
-export const ARRAY_BIGINT: Array<any> = [BIGINT, BIGINT_INSTANCE, 9007199254740991n];
-// Array with `boolean`.
-export const ARRAY_BOOLEAN: Array<any> = [true, false, TRUE_INSTANCE, FALSE_INSTANCE, false, FALSE, TRUE];
-// Array with `Class` instances.
-export const ARRAY_CLASS: Array<any> = [new Class(), new Class()];
-// Array with `function`.
-export const ARRAY_FUNCTION: Array<any> =
-  [(x: number, y: string): any => x, (x: number, y: string): any => x, (x: number, y: string): any => x];
-// Array with `null`.
-export const ARRAY_NULL: Array<any> = [null, null, null, NULL, NULL];
-// Array with `number`.
-export const ARRAY_NUMBER: Array<any> = [1, 2, 3, 4, 7, 10, 1000, 3000, 151233, 12352223, NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE];
-// Array with 'object'.
-export const ARRAY_OBJECT_ONE: Array<any> = [{ x: 3000 }, { x: 1 }, { x: 55 }];
-export const ARRAY_OBJECT_TWO: Array<any> =
-  [{ x: 'One Two Three', y: 10000  }, { x: 'One Two Three', y: 10000  }, { x: 'One Two Three', y: 10000  }];
-// Array with `string`.
-export const ARRAY_STRING: Array<any> = [STRING, STRING_INSTANCE, STRING_NEW_INSTANCE, '!@#$%^&*()Company'];
-// Array with `symbol`.
-export const ARRAY_SYMBOL_STRING: Array<any> = [Symbol('String Symbol'), Symbol('String Symbol'), Symbol('String Symbol One'), Symbol('String Symbol Two')];
-export const ARRAY_SYMBOL_NUMBER: Array<any> = [Symbol(1005), Symbol(1002), Symbol(15), Symbol(1)];
-// Array with `undefined`.
-export const ARRAY_UNDEFINED: Array<any> = [undefined, undefined, undefined, UNDEFINED, notDefined];
diff --git a/src/testing/src/big-int.const.ts b/src/testing/src/big-int.const.ts
deleted file mode 100644
index e66af580..00000000
--- a/src/testing/src/big-int.const.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * typeof === 'bigint'
- * instanceof BigInt === false
- * instanceof Number === false
- * instanceof Object === false
- */
-export const BIGINT: any = 9007199254740991n;  // typeof === 'bigint'
-
-/**
- * typeof === 'bigint'
- * instanceof BigInt === false
- * instanceof Number === false
- * instanceof Object === false
- */
-export const BIGINT_INSTANCE: any = BigInt('9007199254740991'); // typeof === 'bigint'
-
-export const BIGINT_EXPECTATION = `BigInt('9007199254740991')`;
diff --git a/src/testing/src/boolean.const.ts b/src/testing/src/boolean.const.ts
deleted file mode 100644
index 571625a7..00000000
--- a/src/testing/src/boolean.const.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * typeof === 'boolean'
- * instanceof Boolean === false
- * instanceof Object === false
- */
-export const FALSE: any = false; // typeof === 'boolean'
-
-/**
- * typeof === 'boolean'
- * instanceof Boolean === false
- * instanceof Object === false
- */
-export const TRUE: any = true; // typeof === 'boolean'
-
-
-/**
- * typeof === 'boolean'
- * instanceof Boolean === true
- * instanceof Object === true
- */
-// tslint:disable-next-line: no-construct
-export const FALSE_INSTANCE: any = new Boolean(FALSE); // instanceof Boolean
-// tslint:disable-next-line: no-construct
-export const TRUE_INSTANCE: any = new Boolean(TRUE);  // instanceof Boolean
-
-export const FALSE_EXPECTATION = `new Boolean(${FALSE})`;
-export const TRUE_EXPECTATION = `new Boolean(${TRUE})`;
diff --git a/src/testing/src/class.const.ts b/src/testing/src/class.const.ts
deleted file mode 100644
index 3c1ab434..00000000
--- a/src/testing/src/class.const.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-// Constant.
-import { STRING } from './string.const';
-import { NUMBER } from './number.const';
-import { SYMBOL_STRING, SYMBOL_NUMBER } from './strict/symbol.const';
-// Interface.
-import { Person } from '../interface/person.interface';
-/**
- * typeof === 'function'
- * instanceof Class === false
- * instanceof Function === true
- * instanceof Object === true
- */
-export class Class {
-
-  1030405027 = 'my new number';
-  5 = 'my number';
-
-  firstName = 'My name';
-  surname = 'Surname';
-
-  x = NUMBER;
-  y = STRING;
-
-  get [NUMBER](): number {
-    return this.x;
-  }
-  get [STRING](): string {
-    return this.y;
-  }
-
-  get [SYMBOL_NUMBER](): number {
-    return this.x;
-  }
-
-  get [SYMBOL_STRING](): string {
-    return this.y;
-  }
-}
-
-/**
- * typeof === 'object'
- * instanceof Class === true
- * instanceof Function === false
- * instanceof Object === true
- */
-export const CLASS = new Class();
-
-
-export class Persons implements Person {
-  firstName = '';
-  surname = '';
-  age = 15;
-}
-
-export class PersonCopy {
-  firstName = '';
-  surname = '';
-  age = 15;
-}
-
-export const PERSON: Persons = new Persons();
-export const PERSON_COPY: PersonCopy = new PersonCopy();
diff --git a/src/testing/src/function.const.ts b/src/testing/src/function.const.ts
deleted file mode 100644
index 1605c971..00000000
--- a/src/testing/src/function.const.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-/**
- * typeof === 'function'
- * instanceof Function === true
- * instanceof Object === true
- */
-export const FUNCTION: any = (x: number, y: string): any => x + y;
-
-export function functionConstructor(this: any, ...args: any[]): any {
-  if (args) {
-    args.forEach((arg, index: number) => this[index] = arg[index]);
-  }
-  return this;
-}
diff --git a/src/testing/src/not-defined.const.ts b/src/testing/src/not-defined.const.ts
deleted file mode 100644
index d0483860..00000000
--- a/src/testing/src/not-defined.const.ts
+++ /dev/null
@@ -1 +0,0 @@
-export let notDefined: any; // typeof === 'undefined'
diff --git a/src/testing/src/null.const.ts b/src/testing/src/null.const.ts
deleted file mode 100644
index c2294691..00000000
--- a/src/testing/src/null.const.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-/**
- * typeof === 'object'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-export const NULL: any = null;
diff --git a/src/testing/src/number.const.ts b/src/testing/src/number.const.ts
deleted file mode 100644
index 5784508a..00000000
--- a/src/testing/src/number.const.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-export const NUMBER: any = 10304050;
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-export const NUMBER_INSTANCE: any = Number(NUMBER);
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === true
- * instanceof Object === true
- */
-// tslint:disable-next-line: no-construct
-export const NUMBER_NEW_INSTANCE: any = new Number(NUMBER);
diff --git a/src/testing/src/object.const.ts b/src/testing/src/object.const.ts
deleted file mode 100644
index cd3e1821..00000000
--- a/src/testing/src/object.const.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-// Constant.
-import { NUMBER } from './number.const';
-import { STRING } from './string.const';
-import { SYMBOL_NUMBER, SYMBOL_STRING } from './strict/symbol.const';
-// Interface.
-import { DataDescriptor, } from '../interface';
-import { ObjectOne, ObjectTwo } from '../interface';
-// Type.
-import { ThisAccessorDescriptor } from '../type/this-accessor-descriptor.type';
-/**
- * typeof === 'object'
- * instanceof Boolean === false
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === true
- * instanceof String === false
- * instanceof Symbol === false
- */
-export const OBJECT_ONE: ObjectOne = {
-  'key as string': true,
-  1030405027: 'key is number',
-  5: 'key is also number',
-  [NUMBER]: 'key is number',
-  [STRING]: 'key is string',
-  [SYMBOL_NUMBER]: 'key is symbol number',
-  [SYMBOL_STRING]: 6,
-  x: 3000
-};
-
-/**
- * typeof === 'object'
- * instanceof Boolean === false
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === true
- * instanceof String === false
- * instanceof Symbol === false
- */
-export const OBJECT_TWO: ObjectTwo = { x: 'One Two Three', y: 10000  };
-
-/**
- * typeof === 'object'
- * instanceof Boolean === false
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === true
- * instanceof String === false
- * instanceof Symbol === false
- */
-export const OBJECT_ONE_NEW = new Object(OBJECT_ONE);
-
-/**
- * typeof === 'object'
- * instanceof Boolean === false
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === true
- * instanceof String === false
- * instanceof Symbol === false
- */
-export const OBJECT_TWO_NEW = new Object(OBJECT_TWO);
-
-
-export const DATA_DESCRIPTOR: DataDescriptor<string> = {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: 'my value'
-}
-
-export const ACCESSOR_DESCRIPTOR: ThisAccessorDescriptor<string | undefined, ObjectOne> =  {
-  configurable: true,
-  enumerable: true,
-  get(): string | undefined {
-    return this[5];
-  },
-  set(value: string | undefined): void {
-    this[5] = value;
-  }
-}
\ No newline at end of file
diff --git a/src/testing/src/strict/array.const.ts b/src/testing/src/strict/array.const.ts
deleted file mode 100644
index af8056d2..00000000
--- a/src/testing/src/strict/array.const.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-// Constant.
-import { BIGINT, BIGINT_INSTANCE } from './big-int.const';
-import { Class } from './class.const';
-import { FALSE, TRUE, TRUE_INSTANCE, FALSE_INSTANCE } from './boolean.const';
-import { NULL } from './null.const';
-import { NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE } from './number.const';
-import { STRING, STRING_INSTANCE, STRING_NEW_INSTANCE } from './string.const';
-import { UNDEFINED } from './undefined.const';
-import { notDefined } from './not-defined.const';
-// Interface.
-import { ObjectOne, ObjectTwo } from '../../interface';
-// Type.
-import { Func } from '../../../type/func.type';
-
-// Arrays.
-// Array with `bigint`.
-export const ARRAY_BIGINT: Array<bigint> = [BIGINT, BIGINT_INSTANCE, 9007199254740991n];
-// Array with `boolean`.
-// tslint:disable-next-line: ban-types
-export const ARRAY_BOOLEAN: Array<boolean | Boolean> = [true, false, TRUE_INSTANCE, FALSE_INSTANCE, false, FALSE, TRUE];
-// Array with `Class` instances.
-export const ARRAY_CLASS: Array<Class> = [new Class(), new Class()];
-// Array with `function`.
-export const ARRAY_FUNCTION: Array<Func> =
-  [(x: number, y: string): any => x, (x: number, y: string): any => x, (x: number, y: string): any => x];
-// Array with `null`.
-export const ARRAY_NULL: Array<null> = [null, null, null, NULL, NULL];
-// Array with `number`.
-// tslint:disable-next-line: ban-types
-export const ARRAY_NUMBER: Array<number | Number> = [1, 2, 3, 4, 7, 10, 1000, 3000, 151233, NUMBER, NUMBER_INSTANCE, NUMBER_NEW_INSTANCE];
-// Array with 'object'.
-export const ARRAY_OBJECT_ONE: Array<ObjectOne> = [{ [NUMBER]: 'my number', x: 3000 }, { [NUMBER]: 'my number', x: 1 }];
-export const ARRAY_OBJECT_TWO: Array<ObjectTwo> = [{ x: 'One Two Three', y: 10000  }, { x: 'One Two Three', y: 10000  }, { x: 'One Two Three', y: 10000  }];
-// Array with `string`.
-// tslint:disable-next-line: ban-types
-export const ARRAY_STRING: Array<string | String> = [STRING, STRING_INSTANCE, STRING_NEW_INSTANCE, '!@#$%^&*()Company'];
-// Array with `symbol`.
-export const ARRAY_SYMBOL_NUMBER: Array<symbol> = [Symbol(1005), Symbol(1002), Symbol(15), Symbol(1)];
-export const ARRAY_SYMBOL_STRING: Array<symbol> = [Symbol('String Symbol'), Symbol('String Symbol'), Symbol('String Symbol One'), Symbol('String Symbol Two')];
-// Array with `undefined`.
-export const ARRAY_UNDEFINED: Array<undefined | unknown> = [undefined, undefined, undefined, UNDEFINED, notDefined];
diff --git a/src/testing/src/strict/big-int.const.ts b/src/testing/src/strict/big-int.const.ts
deleted file mode 100644
index 95f04679..00000000
--- a/src/testing/src/strict/big-int.const.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * typeof === 'bigint'
- * instanceof BigInt === false
- * instanceof Number === false
- * instanceof Object === false
- */
-export const BIGINT = 9007199254740991n;  // typeof === 'bigint'
-
-/**
- * typeof === 'bigint'
- * instanceof BigInt === false
- * instanceof Number === false
- * instanceof Object === false
- */
-export const BIGINT_INSTANCE: bigint = BigInt('9007199254740991'); // typeof === 'bigint'
-
-export const BIGINT_EXPECTATION = `BigInt('9007199254740991')`;
diff --git a/src/testing/src/strict/boolean.const.ts b/src/testing/src/strict/boolean.const.ts
deleted file mode 100644
index a1fd7e5b..00000000
--- a/src/testing/src/strict/boolean.const.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * typeof === 'boolean'
- * instanceof Boolean === false
- * instanceof Object === false
- */
-export const FALSE = false; // typeof === 'boolean'
-
-/**
- * typeof === 'boolean'
- * instanceof Boolean === false
- * instanceof Object === false
- */
-export const TRUE = true; // typeof === 'boolean'
-
-
-/**
- * typeof === 'boolean'
- * instanceof Boolean === true
- * instanceof Object === true
- */
-// tslint:disable-next-line: ban-types no-construct
-export const FALSE_INSTANCE: Boolean = new Boolean(FALSE); // instanceof Boolean
-// tslint:disable-next-line: ban-types no-construct
-export const TRUE_INSTANCE: Boolean = new Boolean(TRUE);  // instanceof Boolean
-
-export const FALSE_EXPECTATION = `new Boolean(${FALSE})`;
-export const TRUE_EXPECTATION = `new Boolean(${TRUE})`;
diff --git a/src/testing/src/strict/class.const.ts b/src/testing/src/strict/class.const.ts
deleted file mode 100644
index 1ec4c568..00000000
--- a/src/testing/src/strict/class.const.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-// Constant.
-import { STRING } from './string.const';
-import { NUMBER } from './number.const';
-import { SYMBOL_STRING, SYMBOL_NUMBER } from './symbol.const';
-// Interface.
-import { Person } from '../../interface/person.interface';
-
-/**
- * typeof === 'function'
- * instanceof Class === false
- * instanceof Function === true
- * instanceof Object === true
- */
-export class Class {
-
-  1030405027 = 'my new number';
-  5 = 'my number';
-
-  firstName = 'My name';
-  surname = 'Surname';
-
-  x = NUMBER;
-  y = STRING;
-
-  get [NUMBER](): number {
-    return this.x;
-  }
-  get [STRING](): string {
-    return this.y;
-  }
-
-  get [SYMBOL_NUMBER](): number {
-    return this.x;
-  }
-
-  get [SYMBOL_STRING](): string {
-    return this.y;
-  }
-}
-
-export class TestClass extends Class {}
-
-export const TEST_CLASS = new TestClass();
-
-/**
- * typeof === 'object'
- * instanceof Class === true
- * instanceof Function === false
- * instanceof Object === true
- */
-export const CLASS = new Class();
-
-
-export class Persons implements Person {
-  firstName = '';
-  surname = '';
-  age = 15;
-}
-
-export class PersonsCopy {
-  firstName = '';
-  surname = '';
-  age = 15;
-}
-
-export const PERSON: Persons = new Persons();
-export const PERSON_COPY: PersonsCopy = new PersonsCopy();
diff --git a/src/testing/src/strict/function.const.ts b/src/testing/src/strict/function.const.ts
deleted file mode 100644
index 0f9b0095..00000000
--- a/src/testing/src/strict/function.const.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import { Func } from '../../../type/func.type';
-import { Person } from '../../interface/person.interface';
-/**
- * typeof === 'function'
- * instanceof Function === true
- * instanceof Object === true
- */
-export const FUNCTION: Func = (x: number, y: string): any => x + y;
-
-export function personFunctionConstructor(this: Person, ...args: any[]): Person {
-  if (args) {
-    this.firstName = args[0];
-    this.surname = args[1];
-    this.age = args[2];
-    this.sex = args[3];
-  }
-  return this;
-}
diff --git a/src/testing/src/strict/not-defined.const.ts b/src/testing/src/strict/not-defined.const.ts
deleted file mode 100644
index 3e9514d2..00000000
--- a/src/testing/src/strict/not-defined.const.ts
+++ /dev/null
@@ -1 +0,0 @@
-export let notDefined: unknown;
diff --git a/src/testing/src/strict/null.const.ts b/src/testing/src/strict/null.const.ts
deleted file mode 100644
index 8c89e296..00000000
--- a/src/testing/src/strict/null.const.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-/**
- * typeof === 'object'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-export const NULL: null = null;
diff --git a/src/testing/src/strict/number.const.ts b/src/testing/src/strict/number.const.ts
deleted file mode 100644
index a3f854b0..00000000
--- a/src/testing/src/strict/number.const.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-export const NUMBER = 10304050;
-
-/**
- * typeof === 'number
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- */
-export const NUMBER_INSTANCE = Number(NUMBER);
-
-/**
- * typeof === 'number'
- * instanceof Function === false
- * instanceof Number === true
- * instanceof Object === true
- */
-// tslint:disable-next-line: ban-types no-construct
-export const NUMBER_NEW_INSTANCE: Number = new Number(NUMBER);
diff --git a/src/testing/src/strict/string.const.ts b/src/testing/src/strict/string.const.ts
deleted file mode 100644
index 52457556..00000000
--- a/src/testing/src/strict/string.const.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * typeof === 'string'
- * instanceof Function === false
- * instanceof Object === false
- * instanceof String === false
- */
-export const STRING = '!@#$%^&*()Company';
-
-/**
- * typeof === 'string'
- * instanceof Function === false
- * instanceof Object === false
- * instanceof String === false
- */
-export const STRING_INSTANCE = String(STRING);
-
-/**
- * typeof === 'string'
- * instanceof Function === false
- * instanceof Object === true
- * instanceof String === true
- */
-// tslint:disable-next-line: ban-types no-construct
-export const STRING_NEW_INSTANCE: String = new String(STRING);
diff --git a/src/testing/src/strict/symbol.const.ts b/src/testing/src/strict/symbol.const.ts
deleted file mode 100644
index f426fd74..00000000
--- a/src/testing/src/strict/symbol.const.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { NUMBER } from './number.const';
-import { STRING } from './string.const';
-/**
- * typeof === 'symbol'
- * instanceof Boolean === false
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- * instanceof String === false
- * instanceof Symbol === false
- */
-export const SYMBOL_NUMBER: unique symbol = Symbol(NUMBER);
-export const SYMBOL_STRING: unique symbol = Symbol(STRING);
diff --git a/src/testing/src/strict/undefined.const.ts b/src/testing/src/strict/undefined.const.ts
deleted file mode 100644
index 1cfe840a..00000000
--- a/src/testing/src/strict/undefined.const.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-/**
- * typeof === 'undefined'
- * instanceof Boolean === false
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- * instanceof String === false
- */
-export const UNDEFINED: undefined = undefined;
diff --git a/src/testing/src/string.const.ts b/src/testing/src/string.const.ts
deleted file mode 100644
index 75094239..00000000
--- a/src/testing/src/string.const.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * typeof === 'string'
- * instanceof Function === false
- * instanceof Object === false
- * instanceof String === false
- */
-export const STRING: any = '!@#$%^&*()Company';
-
-/**
- * typeof === 'string'
- * instanceof Function === false
- * instanceof Object === false
- * instanceof String === false
- */
-export const STRING_INSTANCE: any = String(STRING);
-
-/**
- * typeof === 'string'
- * instanceof Function === false
- * instanceof Object === true
- * instanceof String === true
- */
-// tslint:disable-next-line: no-construct
-export const STRING_NEW_INSTANCE: any = new String(STRING);
diff --git a/src/testing/src/symbol.const.ts b/src/testing/src/symbol.const.ts
deleted file mode 100644
index e83f2a8f..00000000
--- a/src/testing/src/symbol.const.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { NUMBER } from './number.const';
-import { STRING } from './string.const';
-/**
- * typeof === 'symbol'
- * instanceof Boolean === false
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- * instanceof String === false
- * instanceof Symbol === false
- */
-export const SYMBOL_NUMBER: any = Symbol(NUMBER);
-export const SYMBOL_STRING: any = Symbol(STRING);
diff --git a/src/testing/src/undefined.const.ts b/src/testing/src/undefined.const.ts
deleted file mode 100644
index 4b4c5283..00000000
--- a/src/testing/src/undefined.const.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-/**
- * typeof === 'undefined'
- * instanceof Boolean === false
- * instanceof Function === false
- * instanceof Number === false
- * instanceof Object === false
- * instanceof String === false
- */
-export const UNDEFINED: any = undefined;
diff --git a/src/testing/type/index.ts b/src/testing/type/index.ts
deleted file mode 100644
index d9bd143d..00000000
--- a/src/testing/type/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { ThisAccessorDescriptor } from './this-accessor-descriptor.type';
diff --git a/src/testing/type/this-accessor-descriptor.type.ts b/src/testing/type/this-accessor-descriptor.type.ts
deleted file mode 100644
index 08fe9f71..00000000
--- a/src/testing/type/this-accessor-descriptor.type.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { AccessorDescriptor } from '../interface/accessor-descriptor.interface';
-export type ThisAccessorDescriptor<Value, Obj = any> = AccessorDescriptor<Value> & ThisType<Obj>;
diff --git a/src/type/any-boolean.type.ts b/src/type/any-boolean.type.ts
index df2b5e99..835c7619 100644
--- a/src/type/any-boolean.type.ts
+++ b/src/type/any-boolean.type.ts
@@ -1,3 +1,4 @@
-// Represents `boolean` type or `Boolean` object.
-// tslint:disable-next-line: ban-types
+/**
+ * A `boolean` type or an instance of a `Boolean`.
+ */
 export type AnyBoolean = Exclude<boolean | Boolean, true | false>;
diff --git a/src/type/any-number.type.ts b/src/type/any-number.type.ts
index 82c6b357..e8512b4c 100644
--- a/src/type/any-number.type.ts
+++ b/src/type/any-number.type.ts
@@ -1,3 +1,4 @@
-// Represents `number` type or `Number` object.
-// tslint:disable-next-line: ban-types
+/**
+ * A `number` type or an instance of a `Number`.
+ */
 export type AnyNumber = number | Number;
diff --git a/src/type/any-string.type.ts b/src/type/any-string.type.ts
index 6ea53f0a..f424eeb8 100644
--- a/src/type/any-string.type.ts
+++ b/src/type/any-string.type.ts
@@ -1,3 +1,4 @@
-// Represents `string` type or `String` object.
-// tslint:disable-next-line: ban-types
+/**
+ * A `string` type or an instance of a `String`.
+ */
 export type AnyString = string | String;
diff --git a/src/type/callback-payload.type.ts b/src/type/callback-payload.type.ts
new file mode 100644
index 00000000..e586573f
--- /dev/null
+++ b/src/type/callback-payload.type.ts
@@ -0,0 +1,22 @@
+import { GenericObject } from './generic-object.type';
+/**
+ * Experimental shape for a generic type variable `Payload`.
+ */
+export type CallbackPayload<Payload = object> = GenericObject & {
+
+  /**
+   * An optional action of a `string` type that describes the cause of performed callback.
+   */
+  action?: string;
+
+  /**
+   * An optional name of the function or method of a `string` type that performed callback.
+   */
+  name?: string;
+
+  /**
+   * An optional name of the parameter of a `string` type to which performed callback relates.
+   */
+  param?: string;
+
+} & Payload;
diff --git a/src/type/constructor.type.ts b/src/type/constructor.type.ts
index 5b3885dd..e5798954 100644
--- a/src/type/constructor.type.ts
+++ b/src/type/constructor.type.ts
@@ -1,4 +1,4 @@
 /**
- * Class type.
+ * An instance of a type from the provided generic type variable `Type`.
  */
 export type Constructor<Type> = new (...args: any[]) => Type;
diff --git a/src/type/cycle-hook.type.ts b/src/type/cycle-hook.type.ts
deleted file mode 100644
index 639847be..00000000
--- a/src/type/cycle-hook.type.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-export type CycleHook =
-  | 'ngAfterContentInit'
-  | 'ngAfterContentChecked'
-  | 'ngAfterViewInit'
-  | 'ngAfterViewChecked'
-  | 'ngAfterViewChecked'
-  | 'ngOnInit'
-  | 'ngOnDestroy'
-  | 'ngOnChanges';
diff --git a/src/type/defined.type.ts b/src/type/defined.type.ts
index 76f01de9..7bb13d22 100644
--- a/src/type/defined.type.ts
+++ b/src/type/defined.type.ts
@@ -1,2 +1,5 @@
-import { Never } from './never.type';
-export type Defined<Type> = Never<undefined, Type>;
+/**
+ * A generic type `Defined` indicates the generic type variable `Type` is never `undefined`.
+ * It takes generic type variable `Type` constrained by `undefined` by using `Never` which constraint causes its change to `never`.
+ */
+export type Defined<Type> = Type extends undefined ? never : Type;
diff --git a/src/type/foreach-callback.type.ts b/src/type/foreach-callback.type.ts
new file mode 100644
index 00000000..21d4ec84
--- /dev/null
+++ b/src/type/foreach-callback.type.ts
@@ -0,0 +1,16 @@
+/**
+ * Represents a callback function of `forEach()` method which is executed once for each element.
+ * @param result The result of the check of a `boolean` type.
+ * @param value The value that has been checked of a generic type variable `Value`.
+ * @param index An optional `number` of checked `array` element.
+ * @param array An optional `array` of `any` type that each element is checked.
+ * @param payload An optional `object` of a generic type variable `Payload` to provide more data.
+ * @returns The return value is void.
+ */
+export type ForEachCallback<Value = any, Payload = object> = (
+  result: boolean,
+  value: Value,
+  index: number,
+  array: any[],
+  payload?: Payload
+) => void;
diff --git a/src/type/func.type.ts b/src/type/func.type.ts
deleted file mode 100644
index 9d3d92a4..00000000
--- a/src/type/func.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-/**
- * Function type.
- */
-export type Func = (...param: any) => any;
diff --git a/src/type/generic-object.type.ts b/src/type/generic-object.type.ts
new file mode 100644
index 00000000..771f2b07
--- /dev/null
+++ b/src/type/generic-object.type.ts
@@ -0,0 +1,6 @@
+/**
+ * The type of generic object that takes generic type variable `Value`.
+ */
+export type GenericObject<Value = any> = {
+  [index: string]: Value;
+};
diff --git a/src/type/index.ts b/src/type/index.ts
deleted file mode 100644
index b6eca24c..00000000
--- a/src/type/index.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-export { AnyBoolean } from './any-boolean.type';
-export { AnyNumber } from './any-number.type';
-export { AnyString } from './any-string.type';
-export { Constructor } from './constructor.type';
-export { CycleHook } from './cycle-hook.type';
-export { Defined } from './defined.type';
-export { Func } from './func.type';
-export { Key } from './key.type';
-export { Never } from './never.type';
-export { NotUndefined } from './not-undefined.type';
-export { Primitive } from './primitive.type';
-export { Primitives } from './primitives.type';
-export { ResultCallback } from './result-callback.type';
-export { Type } from './type.type';
-export { Types } from './types.type';
diff --git a/src/type/key.type.ts b/src/type/key.type.ts
deleted file mode 100644
index 0e37731d..00000000
--- a/src/type/key.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-/**
- * Name of the `object` property.
- */
-export type Key =  number | string | symbol;
diff --git a/src/type/never.type.ts b/src/type/never.type.ts
index 7d1561fe..af0e0343 100644
--- a/src/type/never.type.ts
+++ b/src/type/never.type.ts
@@ -1,2 +1,5 @@
-// Choose a type to exclude. A generic `Type` is never a `Not` type.
+/**
+ * A generic type `Never` indicates the generic type variable `Type` is never of the generic type variable `Not`.
+ * It takes generic type variable `Type` constrained by a generic type variable `Not` which constraint causes its change to `never`.
+ */
 export type Never<Not, Type> = Type extends Not ? never : Type;
diff --git a/src/type/not-undefined.type.ts b/src/type/not-undefined.type.ts
index c05f1132..68384e2a 100644
--- a/src/type/not-undefined.type.ts
+++ b/src/type/not-undefined.type.ts
@@ -1 +1,5 @@
-export type NotUndefined<T> = T extends undefined | null ? never : T;
+/**
+ * A generic type `NotUndefined` represents any type instead of `undefined`. It takes generic type variable `Type` constrained by
+ * `undefined` which constraint causes its change to `never`.
+ */
+export type NotUndefined<Type> = Type extends undefined ? never : Type;
diff --git a/src/type/number-between.type.ts b/src/type/number-between.type.ts
new file mode 100644
index 00000000..6e88a903
--- /dev/null
+++ b/src/type/number-between.type.ts
@@ -0,0 +1,13 @@
+// Type.
+import { AnyNumber } from './any-number.type';
+// Interface.
+import { MinMax } from '../interface/min-max.interface';
+/**
+ * A `number` type or an instance of `Number` between a specified range takes generic type variable `Min` and `Max` constrained by `number`
+ * type as range, and takes generic type variable `Type` constrained by generic type `AnyNumber` as the type.
+ */
+export type NumberBetween<
+  Min extends number,
+  Max extends number,
+  Type extends AnyNumber = number
+> = Type & MinMax<Min, Max>;
diff --git a/src/type/primitive.type.ts b/src/type/primitive.type.ts
index 86588765..c8404c2d 100644
--- a/src/type/primitive.type.ts
+++ b/src/type/primitive.type.ts
@@ -1,4 +1,11 @@
 /**
- * All primitives.
+ * All primitives types.
  */
-export type Primitive = boolean | bigint | null | number | string | symbol | undefined;
+export type Primitive =
+  | boolean
+  | bigint
+  | null
+  | number
+  | string
+  | symbol
+  | undefined;
diff --git a/src/type/primitives.type.ts b/src/type/primitives.type.ts
index c09ad762..44a0f5ef 100644
--- a/src/type/primitives.type.ts
+++ b/src/type/primitives.type.ts
@@ -1,4 +1,11 @@
 /**
- * All primitives as `string`.
+ * All primitives types as `string`.
  */
-export type Primitives = 'bigint' | 'boolean' | 'null' | 'number' | 'string' | 'symbol' | 'undefined';
+export type Primitives =
+  | 'bigint'
+  | 'boolean'
+  | 'null'
+  | 'number'
+  | 'string'
+  | 'symbol'
+  | 'undefined';
diff --git a/src/type/result-callback.type.ts b/src/type/result-callback.type.ts
index 3779cdfa..bc94c232 100644
--- a/src/type/result-callback.type.ts
+++ b/src/type/result-callback.type.ts
@@ -1 +1,15 @@
-export type ResultCallback = (result: boolean, value?: any) => boolean;
+/**
+ * Represents a callback function with parameters, the `value` that has been checked, the `result` of this check, and an optional
+ * `payload`.
+ * @var Value A generic type variable `Value` determines `value` parameter type, by default `any`.
+ * @var Payload Generic type variable `Payload` indicates `payload` parameter type, by default `object`.
+ * @param result The check result of a `boolean` type of the given `value`.
+ * @param value The value of the generic type variable Value to check and which the given check `result` applies.
+ * @param payload An optional `object` of a generic type variable `Payload` to provide more data.
+ * @returns The return value is a `boolean` indicating the check result of the given `value`.
+ */
+ export type ResultCallback<Value = any, Payload = object> = (
+  result: boolean,
+  value: Value,
+  payload?: Payload
+) => boolean;
diff --git a/src/type/string-of-length.type.ts b/src/type/string-of-length.type.ts
new file mode 100644
index 00000000..da5a8989
--- /dev/null
+++ b/src/type/string-of-length.type.ts
@@ -0,0 +1,13 @@
+// Interface.
+import { MinMax } from '../interface/min-max.interface';
+// Type.
+import { AnyString } from './any-string.type';
+/**
+ * A `string` type or an instance of `String` of length between a specified range takes generic type variable `Min` and `Max` constrained by
+ * `number` type as length, and takes generic type variable `Type` constrained by generic type `AnyString` as the type.
+ */
+export type StringOfLength<
+  Min extends number,
+  Max extends number,
+  Type extends AnyString = string
+> = Type & MinMax<Min, Max>;
diff --git a/src/type/type.type.ts b/src/type/type.type.ts
index db8ab3c9..c0b1b53a 100644
--- a/src/type/type.type.ts
+++ b/src/type/type.type.ts
@@ -1,6 +1,5 @@
-import { Func } from './func.type';
 import { Primitive } from './primitive.type';
 /**
- * Main types.
+ * The main types consist of `Function`, `object`, and `Primitive`.
  */
-export type Type = Func | object | Primitive;
+export type Type = Function | object | Primitive;
diff --git a/src/type/types.type.ts b/src/type/types.type.ts
index dae586b8..1473fccc 100644
--- a/src/type/types.type.ts
+++ b/src/type/types.type.ts
@@ -1,6 +1,6 @@
 import { Constructor } from './constructor.type';
 import { Primitives } from './primitives.type';
 /**
- * Main types as `string` values.
+ * The main types as string values, besides the `Constructor` which is an instance of an Obj.
  */
 export type Types<Obj> = Constructor<Obj> | 'function' | 'object' | Primitives;
diff --git a/src/type/undefined.type.ts b/src/type/undefined.type.ts
index 385cf7eb..8edf5f6b 100644
--- a/src/type/undefined.type.ts
+++ b/src/type/undefined.type.ts
@@ -1,2 +1,5 @@
-// Undefined or `never` - treat types as `never` excluding `undefined`.
+/**
+ * A generic type `Undefined` indicates generic type variable `Type` as undefined. It takes generic type variable `Type` causing other
+ * types than `undefined` its change to never.
+ */
 export type Undefined<Type> = Type extends undefined ? Type : never;
