@planet-matrix/mobius-model 0.3.0 → 0.4.0

package/src/basic/helper.ts

@@ -0,0 +1,276 @@
+
+import { isAnyFunction, isFunction } from "./is.ts"
+
+import { booleanFrom } from "./boolean.ts"
+
+/**
+ * Return the input value as is, ignoring any additional arguments.
+ *
+ * @example
+ * ```
+ * // Expect: 5
+ * const example1 = asIs(5)
+ * // Expect: "hello"
+ * const example2 = asIs("hello", 1, 2, 3)
+ * ```
+ */
+export const asIs = <T = unknown>(target: T, ..._args: unknown[]): T => target
+/**
+ * Return undefined, ignoring any input arguments.
+ *
+ * @example
+ * ```
+ * // Expect: undefined
+ * const example1 = asUndefined()
+ * // Expect: undefined
+ * const example2 = asUndefined(1, "hello", null)
+ * ```
+ */
+export const asUndefined = (..._target: unknown[]): undefined => undefined
+/**
+ * Return null, ignoring any input arguments.
+ *
+ * @example
+ * ```
+ * // Expect: null
+ * const example1 = asNull()
+ * // Expect: null
+ * const example2 = asNull(1, "hello", undefined)
+ * ```
+ */
+export const asNull = (..._target: unknown[]): null => null
+/**
+ * Return void, ignoring any input arguments.
+ *
+ * @example
+ * ```
+ * // Expect: void
+ * const example1 = asVoid()
+ * // Expect: void
+ * const example2 = asVoid(1, "hello", null)
+ * ```
+ */
+export const asVoid = (..._target: unknown[]): void => { /* do nothing */ }
+
+/**
+ * Check whether two values are strictly equal using `===`.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * const example1 = isStrictEqual(1, 1)
+ * // Expect: false
+ * const example2 = isStrictEqual(1, "1")
+ * ```
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness}
+ */
+export const isStrictEqual = (v1: unknown, v2: unknown): boolean => v1 === v2
+
+/**
+ * Check whether two values are loosely equal using `==`.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * const example1 = isLooseEqual(1, "1")
+ * // Expect: false
+ * const example2 = isLooseEqual(0, "1")
+ * ```
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness}
+ */
+// eslint-disable-next-line eqeqeq
+export const isLooseEqual = (v1: unknown, v2: unknown): boolean => v1 == v2
+
+/**
+ * Check whether two values are equal using `Object.is`.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * const example1 = isObjectEqual(NaN, NaN)
+ * // Expect: false
+ * const example2 = isObjectEqual(0, -0)
+ * ```
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is}
+ */
+export const isObjectEqual = (v1: unknown, v2: unknown): boolean => Object.is(v1, v2)
+
+/**
+ * Invoke the conditional function with the target value, according to the predicate result.
+ *
+ * @example
+ * ```
+ * const example1 = ifElse(true, () => "yes", () => "no")
+ * // Expect: "yes"
+ * const example2 = ifElse(false, () => "yes", () => "no")
+ * // Expect: "no"
+ * ```
+ */
+export const ifElse = <X = unknown, TR = unknown, ER = unknown>(
+  pred: unknown,
+  thenFn: (x?: X) => TR,
+  elseFn: (x?: X) => ER,
+  x?: X,
+): TR | ER => {
+  return booleanFrom(isAnyFunction(pred) ? pred(x) : pred) ? thenFn(x) : elseFn(x)
+}
+
+/**
+ * Invoke a function when the predicate result is truthy.
+ *
+ * @example
+ * ```
+ * // Expect: 4
+ * const example1 = when(true, (value?: number) => (value ?? 0) + 1, 3)
+ * // Expect: 3
+ * const example2 = when(false, (value?: number) => (value ?? 0) + 1, 3)
+ * ```
+ */
+export function when<X = unknown, WR = unknown>(pred: unknown, whenFn: (x?: X) => WR): WR
+export function when<X = unknown, WR = unknown>(pred: unknown, whenFn: (x?: X) => WR, x: X): WR | X
+export function when<X = unknown, WR = unknown>(pred: unknown, whenFn: (x?: X) => WR, x?: X): WR | X | undefined {
+  return booleanFrom(isAnyFunction(pred) ? pred(x) : pred) ? whenFn(x) : x
+}
+
+/**
+ * Invoke a function when the predicate result is falsy.
+ *
+ * @example
+ * ```
+ * // Expect: 2
+ * const example1 = unless(false, (value?: number) => (value ?? 0) + 1, 1)
+ * // Expect: 1
+ * const example2 = unless(true, (value?: number) => (value ?? 0) + 1, 1)
+ * ```
+ */
+export function unless<X = unknown, UR = unknown>(pred: unknown, unlessFn: (x?: X) => UR): UR
+export function unless<X = unknown, UR = unknown>(pred: unknown, unlessFn: (x?: X) => UR, x: X): UR
+export function unless<X = unknown, UR = unknown>(
+  pred: unknown,
+  unlessFn: (x?: X) => UR,
+  x?: X,
+): UR | X | undefined {
+  return !booleanFrom(isAnyFunction(pred) ? pred(x) : pred) ? unlessFn(x) : x
+}
+
+/**
+ * Evaluate an immediate if expression.
+ *
+ * @example
+ * ```
+ * // Expect: "yes"
+ * const example1 = iif(true, "yes", "no")
+ * // Expect: "no"
+ * const example2 = iif(false, "yes", "no")
+ * ```
+ *
+ * @see {@link booleanFrom}
+ */
+export const iif = <X = unknown, Y = unknown>(cond: unknown, trueValue: X, falseValue: Y): X | Y => {
+  return booleanFrom(isAnyFunction(cond) ? cond(trueValue) : cond) ? trueValue : falseValue
+}
+
+export type GuardCondition<V> = [judgement: boolean, value: V]
+/**
+ * Pick the first matching value from guard conditions.
+ *
+ * @example
+ * ```
+ * // Expect: "b"
+ * const example1 = guards([
+ *   [false, "a"],
+ *   [true, "b"],
+ * ], "z")
+ * // Expect: "z"
+ * const example2 = guards([[false, "a"]], "z")
+ * ```
+ *
+ * @see {@link https://hackage.haskell.org/package/Boolean-0.2.4/candidate/docs/Data-Boolean.html}
+ * @see {@link https://hackage.haskell.org/package/Boolean-0.2.4/candidate/docs/src/Data-Boolean.html#guardedB}
+ */
+export const guards = <V = unknown>(conditions: Array<GuardCondition<V>>, defaultValue: V): V => {
+  for (const [judgement, value] of conditions) {
+    if (judgement) { return value }
+  }
+  return defaultValue
+}
+
+export type CaseCondition<P, V> = [predicate: (predicated?: P) => boolean, value: V]
+/**
+ * Pick the first matching value from predicate cases.
+ *
+ * @example
+ * ```
+ * // Expect: "mid"
+ * const example1 = cases(3, [
+ *   [(value?: number) => (value ?? 0) > 5, "big"],
+ *   [(value?: number) => (value ?? 0) > 1, "mid"],
+ * ], "small")
+ * // Expect: "small"
+ * const example2 = cases(0, [[(value?: number) => (value ?? 0) > 1, "mid"]], "small")
+ * ```
+ *
+ * @see {@link https://hackage.haskell.org/package/Boolean-0.2.4/candidate/docs/src/Data-Boolean.html#caseB}
+ */
+export const cases = <P = unknown, V = unknown>(
+  predicated: P,
+  conditions: Array<CaseCondition<P, V>>,
+  defaultValue: V,
+): V => {
+  for (const [predicate, value] of conditions) {
+    if (predicate(predicated)) {
+      return value
+    }
+  }
+  return defaultValue
+}
+
+export interface TryCatch {
+  <Target>(tryer: () => Target, catcher: (exception: unknown) => Target): Target
+  <Target>(tryer: () => Target, catchallValue: Target): Target
+  /**
+   * 未提供 `catcher` 或 `catchallValue` 的情况下，若 `tryer` 抛出异常，则返回 `undefined`
+   */
+  <Target>(tryer: () => Target): Target | undefined
+  (tryer: () => void): void
+}
+/**
+ * Execute a function and catch any exception, returning either a catch value or undefined.
+ *
+ * @example
+ * ```
+ * // Expect: "ok"
+ * const example1 = tryCatch(() => "ok", () => "error")
+ * // Expect: "error"
+ * const example2 = tryCatch(() => { throw new Error("fail") }, () => "error")
+ * // Expect: 0
+ * const example3 = tryCatch(() => { throw new Error("fail") }, 0)
+ * // Expect: undefined
+ * const example4 = tryCatch(() => { throw new Error("fail") })
+ */
+export const tryCatch: TryCatch = <Target>(
+  tryer: () => Target,
+  catcherOrCatchallValue?: Target | ((exception: unknown) => Target),
+): Target | undefined => {
+  try {
+    return tryer()
+  }
+  catch (exception) {
+    // NOTE: intended redundant type guard
+    if (catcherOrCatchallValue !== undefined) {
+      if (isFunction(catcherOrCatchallValue)) {
+        return catcherOrCatchallValue(exception)
+      }
+      else {
+        return catcherOrCatchallValue
+      }
+    }
+    else {
+      return undefined
+    }
+  }
+}

package/src/basic/index.ts

@@ -0,0 +1,15 @@
+export * from "./helper.ts"
+export * from "./is.ts"
+export * from "./string.ts"
+export * from "./number.ts"
+export * from "./boolean.ts"
+export * from "./bigint.ts"
+export * from "./symbol.ts"
+export * from "./array.ts"
+export * from "./object.ts"
+export * from "./function.ts"
+export * from "./temporal.ts"
+export * from "./error.ts"
+export * from "./regexp.ts"
+export * from "./promise.ts"
+export * from "./stream.ts"

package/src/basic/is.ts

@@ -0,0 +1,320 @@
+// oxlint-disable no-explicit-any ban-types
+
+import type {
+  AnyAsyncFunction,
+  AnyAsyncGeneratorFunction,
+  AnyFunction,
+  AnyGeneratorFunction,
+  AnySyncFunction,
+  NonPrimitive,
+  PlainObject,
+  Primitive
+} from "#Source/type/index.ts"
+
+/**
+ * 进行类型检测的常用手段包括：
+ *   - typeof: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof
+ *             https://tc39.es/ecma262/#sec-typeof-operator
+ *   - instanceof: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof
+ *   - toString: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString
+ *
+ * - `typeof` operator can operate on non-exist variable.
+ */
+
+/**
+ *
+ */
+export const isPrimitive = (target: unknown): target is Primitive => {
+  return isString(target) || isNumber(target) || isBoolean(target) || isBigInt(target) || isSymbol(target) || isNull(target) || isUndefined(target)
+}
+export const isNonPrimitive = (target: unknown): target is NonPrimitive => {
+  return isPrimitive(target) === false
+}
+export const isString = (target: unknown): target is string => {
+  return Object.prototype.toString.call(target) === "[object String]"
+}
+export const isNumber = (target: unknown): target is number => {
+  return Object.prototype.toString.call(target) === "[object Number]" && isNaN(Number.parseFloat(String(target)))
+}
+export const isNaN = (target: unknown): boolean => {
+  return Number.isNaN(target)
+}
+export const isFiniteNumber = (target: unknown): target is number => {
+  return isNumber(target) && Number.isFinite(target)
+}
+export const isInfiniteNumber = (target: unknown): target is number => {
+  return isNumber(target) && !Number.isFinite(target)
+}
+export const isBoolean = (target: unknown): target is boolean => {
+  return Object.prototype.toString.call(target) === "[object Boolean]"
+}
+export const isTrue = (target: unknown): target is true => {
+  return isBoolean(target) && target === true
+}
+export const isFalse = (target: unknown): target is false => {
+  return isBoolean(target) && target === false
+}
+export const isBigInt = (target: unknown): target is bigint => {
+  return Object.prototype.toString.call(target) === "[object BigInt]"
+}
+export const isSymbol = (target: unknown): target is symbol => {
+  return Object.prototype.toString.call(target) === "[object Symbol]"
+}
+export const isNull = (target: unknown): target is null => {
+  return Object.prototype.toString.call((target)) === "[object Null]"
+}
+export const isUndefined = (target: unknown): target is undefined => {
+  return Object.prototype.toString.call(target) === "[object Undefined]"
+}
+/**
+ * @see {@link https://stackoverflow.com/a/52097700}
+ */
+export const isDefined = <T>(target: T | undefined): target is T => {
+  return isUndefined(target) === false
+}
+export const isNil = (target: unknown): target is (null | undefined) => {
+  return target === null || target === undefined
+}
+
+/**
+ * Predicate whether the target is an Object, use `instanceof` operator to check.
+ *
+ * @see {@link isGeneralObject}, {@link isPlainObject}
+ */
+// oxlint-disable-next-line no-wrapper-object-types
+export const isObject = (target: unknown): target is Object => {
+  // oxlint-disable-next-line no-instanceof-builtins
+  return target instanceof Object
+}
+/**
+ * Predicate whether the target is a general object, use `typeof` operator to check.
+ *
+ * A general object is an object that is:
+ *  - not `null`, not a `function`, not a `primitive`.
+ *
+ * Any other object is a general object:
+ *  - `Array` instance, `Map` instance, `WeakMap` instance, `Set` instance, `Date` instance, etc.
+ *
+ * @example
+ * ```
+ * typeof null // => 'object'
+ * typeof [] // => 'object'
+ * typeof {} // => 'object'
+ * typeof { a: 1 } // => 'object'
+ * typeof (new Map()) // => 'object'
+ * typeof (new WeakMap()) // => 'object'
+ * typeof (new Set()) // => 'object'
+ * typeof (new WeakSet()) // => 'object'
+ * typeof (new Date()) // => 'object'
+ * typeof window // => 'object'
+ * typeof document // => 'object'
+ * ```
+ *
+ * @see {@link isObject}, {@link isPlainObject}
+ */
+// oxlint-disable-next-line no-wrapper-object-types
+export const isGeneralObject = (target: unknown): target is Object => {
+  return target !== null && typeof target === "object"
+}
+/**
+ * Predicate whether the target is a plain object.
+ *
+ * A plain object is an object that is:
+ *  - not `null`, not a `function`, not a `primitive` type,
+ *  - not an `Array`, not a `RegExp`, not a `Date`, not a `Map`, not a `Set`, not a `WeakMap`,
+ *  - not `window`, not a DOM `element`, not an `Error`,
+ *  - not any other customize object type.
+ *
+ * @see {@link isObject}, {@link isGeneralObject}
+ */
+export const isPlainObject = (target: unknown): target is PlainObject => {
+  // 非 null、非 Function、非 Primitive
+  if (target === null || typeof target !== "object") {
+    return false
+  }
+  // 非 Array、非 Regexp、非 Date、非 Map、非 Set、非 Window、非 DOM、非 Error……
+  if (Object.prototype.toString.call(target) !== "[object Object]") {
+    return false
+  }
+  // 非其它自定义类实例对象，allow only plain object literal or Object.create(null)
+  // oxlint-disable-next-line no-unsafe-assignment
+  const proto = Object.getPrototypeOf(target)
+  return proto === Object.prototype || proto === null
+}
+export const isEmptyPlainObject = (target: unknown): target is PlainObject => {
+  return isPlainObject(target) && Reflect.ownKeys(target).length === 0
+}
+
+export function isArray<T>(target: T[]): target is T[]
+export function isArray<T>(target: unknown): target is T[]
+export function isArray<T>(target: unknown): target is T[] {
+  return Array.isArray(target)
+}
+export const isEmptyArray = (target: unknown): target is [] => {
+  return isArray(target) && target.length === 0
+}
+
+export function isArrayLike<T>(target: ArrayLike<T>): target is ArrayLike<T>
+export function isArrayLike<T>(target: unknown): target is ArrayLike<T>
+export function isArrayLike<T>(target: unknown): target is ArrayLike<T> {
+  return isGeneralObject(target) && ("length" in target) && isNumber(target.length)
+}
+
+export function isMap<K, V>(target: Map<K, V>): target is Map<K, V>
+export function isMap<K, V>(target: unknown): target is Map<K, V>
+export function isMap<K, V>(target: unknown): target is Map<K, V> {
+  return Object.prototype.toString.call(target) === "[object Map]"
+}
+
+export function isWeakMap<K extends object, V>(target: WeakMap<K, V>): target is WeakMap<K, V>
+export function isWeakMap<K extends object, V>(target: unknown): target is WeakMap<K, V>
+export function isWeakMap<K extends object, V>(target: unknown): target is WeakMap<K, V> {
+  return Object.prototype.toString.call(target) === "[object WeakMap]"
+}
+
+export function isSet<T>(target: Set<T>): target is Set<T>
+export function isSet<T>(target: unknown): target is Set<T>
+export function isSet<T>(target: unknown): target is Set<T> {
+  return Object.prototype.toString.call(target) === "[object Set]"
+}
+
+export function isWeakSet<T extends object>(target: WeakSet<T>): target is WeakSet<T>
+export function isWeakSet<T extends object>(target: unknown): target is WeakSet<T>
+export function isWeakSet<T extends object>(target: unknown): target is WeakSet<T> {
+  return Object.prototype.toString.call(target) === "[object WeakSet]"
+}
+
+export const isDate = (target: unknown): target is Date => {
+  return Object.prototype.toString.call(target) === "[object Date]"
+}
+
+export const isRegExp = (target: unknown): target is RegExp => {
+  return Object.prototype.toString.call(target) === "[object RegExp]"
+}
+
+export const isError = (target: unknown): target is Error => {
+  return Object.prototype.toString.call(target) === "[object Error]"
+}
+
+export function isPromise<T>(target: Promise<T>): target is Promise<T>
+export function isPromise<T>(target: unknown): target is Promise<T>
+export function isPromise<T>(target: unknown): target is Promise<T> {
+  return Object.prototype.toString.call(target) === "[object Promise]"
+}
+
+// oxlint-disable-next-line no-unsafe-function-type
+export const isFunction = (target: unknown): target is Function => {
+  return typeof target === "function"
+}
+export const isAnyFunction = (target: unknown): target is AnyFunction => {
+  return isFunction(target)
+}
+export const isSyncFunction = (target: unknown): target is AnySyncFunction => {
+  return Object.prototype.toString.call(target) === "[object Function]"
+}
+export const isAsyncFunction = (target: unknown): target is AnyAsyncFunction => {
+  return Object.prototype.toString.call(target) === "[object AsyncFunction]"
+}
+export const isGeneratorFunction = (target: unknown): target is AnyGeneratorFunction => {
+  return Object.prototype.toString.call((target)) === "[object GeneratorFunction]"
+}
+export const isAsyncGeneratorFunction = (target: unknown): target is AnyAsyncGeneratorFunction => {
+  return Object.prototype.toString.call(target) === "[object AsyncGeneratorFunction]"
+}
+
+/**
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_iterable_protocol}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator}
+ */
+export function isIterable<T>(target: Iterable<T>): target is Iterable<T>
+export function isIterable<T>(target: unknown): target is Iterable<T>
+export function isIterable<T>(target: unknown): target is Iterable<T> {
+  // oxlint-disable-next-line no-unsafe-type-assertion no-unsafe-member-access
+  return isGeneralObject(target) && typeof (target as any)[Symbol.iterator] === "function"
+}
+/**
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator}
+ */
+export function isAsyncIterable<T>(target: AsyncIterable<T>): target is AsyncIterable<T>
+export function isAsyncIterable<T>(target: unknown): target is AsyncIterable<T>
+export function isAsyncIterable<T>(target: unknown): target is AsyncIterable<T> {
+  // oxlint-disable-next-line no-unsafe-type-assertion no-unsafe-member-access
+  return isGeneralObject(target) && typeof (target as any)[Symbol.asyncIterator] === "function"
+}
+/**
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_iterator_protocol}
+ */
+export function isIterator<T, TReturn = unknown, TNext = undefined>(target: Iterator<T, TReturn, TNext>): target is Iterator<T, TReturn, TNext>
+export function isIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is Iterator<T, TReturn, TNext>
+export function isIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is Iterator<T, TReturn, TNext> {
+  // oxlint-disable-next-line no-unsafe-type-assertion no-unsafe-member-access
+  return isGeneralObject(target) && typeof (target as any).next === "function"
+}
+export function isAsyncIterator<T, TReturn = unknown, TNext = undefined>(target: AsyncIterator<T, TReturn, TNext>): target is AsyncIterator<T, TReturn, TNext>
+export function isAsyncIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is AsyncIterator<T, TReturn, TNext>
+export function isAsyncIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is AsyncIterator<T, TReturn, TNext> {
+  // oxlint-disable-next-line no-unsafe-type-assertion no-unsafe-member-access
+  return isGeneralObject(target) && typeof (target as any).next === "function"
+}
+export function isIterableIterator<T, TReturn = unknown, TNext = undefined>(target: IterableIterator<T>): target is IterableIterator<T, TReturn, TNext>
+export function isIterableIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is IterableIterator<T, TReturn, TNext>
+export function isIterableIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is IterableIterator<T> {
+  return isIterator<T, TReturn, TNext>(target) && isIterable<T>(target)
+}
+export function isAsyncIterableIterator<T, TReturn = unknown, TNext = undefined>(target: AsyncIterableIterator<T>): target is AsyncIterableIterator<T, TReturn, TNext>
+export function isAsyncIterableIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is AsyncIterableIterator<T, TReturn, TNext>
+export function isAsyncIterableIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is AsyncIterableIterator<T> {
+  return isAsyncIterator<T, TReturn, TNext>(target) && isAsyncIterable<T>(target)
+}
+
+/**
+ * Check `target` and `Window` is both defined
+ * before use the `instanceof` operator to check `target` is instanceof `Window`.
+ */
+export const isWindow = (target: unknown): target is Window => {
+  return isGeneralObject(target) && isDefined(Window) && target instanceof Window
+}
+/**
+ * Check `target` and `Element` is both defined
+ * before use the `instanceof` operator to check `target` is instanceof `Element`.
+ */
+export const isElement = (target: unknown): target is Element => {
+  return isGeneralObject(target) && isDefined(Element) && target instanceof Element
+}
+/**
+ * Check `target` and `Node` is both defined
+ * before use the `instanceof` operator to check `target` is instanceof `Node`.
+ */
+export const isNode = (target: unknown): target is Node => {
+  return isGeneralObject(target) && isDefined(Node) && target instanceof Node
+}
+/**
+ * Check `target` and `HTMLElement` is both defined
+ * before use the `instanceof` operator to check `target` is instanceof `HTMLElement`.
+ */
+export const isHTMLElement = (target: unknown): target is HTMLElement => {
+  return isGeneralObject(target) && isDefined(HTMLElement) && target instanceof HTMLElement
+}
+/**
+ * Check `target` and `HTMLCollection` is both defined
+ * before use the `instanceof` operator to check `target` is instanceof `HTMLCollection`.
+ */
+export const isHTMLCollection = (target: unknown): target is HTMLCollection => {
+  return isGeneralObject(target) && isDefined(HTMLCollection) && target instanceof HTMLCollection
+}
+/**
+ * Check `target` and `Document` is both defined
+ * before use the `instanceof` operator to check `target` is instanceof `Document`.
+ */
+export const isDocument = (target: unknown): target is Document => {
+  return isGeneralObject(target) && isDefined(Document) && target instanceof Document
+}
+/**
+ * Check `target` and `EventTarget` is both defined
+ * before use the `instanceof` operator to check `target` is instanceof `EventTarget`.
+ *
+ * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/API/Event}
+ */
+export const isEventTarget = (target: unknown): target is EventTarget => {
+  return isGeneralObject(target) && isDefined(EventTarget) && target instanceof EventTarget
+}