type-tls 3.2.1 → 3.3.0

package/dist/index.d.ts

@@ -4,3 +4,5 @@ export * from './member';
 export * from './async';
 export * from './buffer';
 export * from "./other";
+export * from './vector';
+export * from './size';

package/dist/member.d.ts

@@ -26,6 +26,15 @@ export type ArrayItemType<Arr> = Arr extends (infer Item)[] ? Item : never;
  * 如果  ItemOrArray 不是数组，则转为数组类型 ItemOrArray[]
  */
 export type FormatAsArray<ItemOrArray> = ItemOrArray extends any[] ? ItemOrArray : ItemOrArray[];
+/**
+ * 格式化为数组格式
+ * @remarks
+ * 如果 value 是数组，则保持不变
+ * 如果  value 不是数组，则转为数组类型
+ * @param value
+ * @returns
+ */
+export declare function formatAsArray<V>(value: V): FormatAsArray<V>;
 /**
  * 格式化对象成员为数组格式
  * @remarks
@@ -35,3 +44,12 @@ export type FormatAsArray<ItemOrArray> = ItemOrArray extends any[] ? ItemOrArray
 export type FormatMemberAsArray<D> = {
     [K in keyof D]: FormatAsArray<D[K]>;
 };
+/**
+ * 格式化对象成员为数组格式
+ * @remarks
+ * 如果 成员 是数组，则保持不变
+ * 如果  成员 不是数组，则转为数组类型
+ *
+ * @returns 返回来的 data 对象，此方法会改变原对象 data，耗会生成新的对象
+ */
+export declare function formatMemberAsArray<D extends {}>(data: D): FormatMemberAsArray<D>;

package/dist/size.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 二维尺寸
+ */
+export interface Size2 {
+    width: number;
+    height: number;
+}
+/**
+ * 三维尺寸
+ */
+export interface Size3 extends Size2 {
+    depth: number;
+}

package/dist/type-tls.iife.js

@@ -1 +1 @@
-var TypeTls=function(e){"use strict";function f(n){var t=typeof n;return n&&(t==="object"||t==="function")}function o(n){var t=n;return n!=null&&(t=n.constructor,t==null&&(t=typeof n)),t}function s(n){switch(n){case void 0:return"undefined";case null:return"null"}let t=typeof n;switch(t){case"function":return n.name;case"string":return n;default:return t}}function y(n){return globalThis[n]}function l(n){let t=o(n);return s(t)}function a(n){return n==null||f(n)?o(n):typeof n}function g(n){var t=a(n);return s(t)}function T(n){var t=typeof n;return n==null||t!=="object"&&t!=="function"}function F(n){let t=n&&n.length;return Number.isInteger(n.length)&&t>=0}function A(n){return n&&typeof n[Symbol.iterator]=="function"}function b(n){return n&&typeof n.next=="function"}const m=/^[A-Za-z_$]+[\w$]*$/;function O(n){return m.test(n)}const d=/(^\s*(async\s+)?\s*(\b[A-Za-z_$]+[\w$]*\b)\s*=>)|(^\s*(async\s+)?\s*\(\s*(\b[A-Za-z_$]+[\w$]*\b)?\s*(,\s*(\b[A-Za-z_$]+[\w$]*\b)\s*)*\)\s*=>)/;function w(n){const t=n.toString();return d.test(t)}const h=globalThis.AsyncFunction??(async function(){}).constructor;function v(n){return n instanceof h}const E=globalThis.GeneratorFunction??(function*(){}).constructor;function $(n){return n instanceof E}const N=globalThis.AsyncGeneratorFunction??(async function*(){}).constructor;function S(n){return n instanceof N}const q=/(^\s*(async\s+)?function\s*(\s|\*)\s*)[A-Za-z_$]+[\w$]*(\s*\()/;function I(n){if(n.name){const t=n.toString();return!q.test(t)}return!0}function G(n,t){return n instanceof Promise?n.then(i=>t(i,!1,void 0),i=>t(void 0,!0,i)):t(n,!1,void 0)}return e.BitFlagEqualTestType=(n=>(n.equal="equal",n.intersect="intersect",n.intersectEqual="intersectEqual",n))(e.BitFlagEqualTestType||{}),(n=>{function t(i){let c;switch(i){case"equal":c=(u,r)=>u===r;case"intersect":c=(u,r)=>u&r;default:c=(u,r)=>(u&r)===u}return c}n.getEqualFun=t})(e.BitFlagEqualTestType||(e.BitFlagEqualTestType={})),e.getExactTypeNameOf=g,e.getExactTypeOf=a,e.getNameOfType=s,e.getTypeByName=y,e.getTypeNameOf=l,e.getTypeOf=o,e.isAnonymousFunction=I,e.isArrayLike=F,e.isArrowFunction=w,e.isAsyncFunction=v,e.isAsyncGeneratorFunction=S,e.isBaseType=T,e.isGeneratorFunction=$,e.isIdentifier=O,e.isIterable=A,e.isIterator=b,e.isObject=f,e.waitAsyncable=G,Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),e}({});
+var TypeTls=function(e){"use strict";function f(n){var t=typeof n;return n&&(t==="object"||t==="function")}function o(n){var t=n;return n!=null&&(t=n.constructor,t==null&&(t=typeof n)),t}function s(n){switch(n){case void 0:return"undefined";case null:return"null"}let t=typeof n;switch(t){case"function":return n.name;case"string":return n;default:return t}}function y(n){return globalThis[n]}function l(n){let t=o(n);return s(t)}function a(n){return n==null||f(n)?o(n):typeof n}function A(n){var t=a(n);return s(t)}function g(n){var t=typeof n;return n==null||t!=="object"&&t!=="function"}function T(n){let t=n&&n.length;return Number.isInteger(n.length)&&t>=0}function m(n){return n&&typeof n[Symbol.iterator]=="function"}function F(n){return n&&typeof n.next=="function"}const b=/^[A-Za-z_$]+[\w$]*$/;function O(n){return b.test(n)}const w=/(^\s*(async\s+)?\s*(\b[A-Za-z_$]+[\w$]*\b)\s*=>)|(^\s*(async\s+)?\s*\(\s*(\b[A-Za-z_$]+[\w$]*\b)?\s*(,\s*(\b[A-Za-z_$]+[\w$]*\b)\s*)*\)\s*=>)/;function d(n){const t=n.toString();return w.test(t)}const h=globalThis.AsyncFunction??(async function(){}).constructor;function E(n){return n instanceof h}const $=globalThis.GeneratorFunction??(function*(){}).constructor;function N(n){return n instanceof $}const S=globalThis.AsyncGeneratorFunction??(async function*(){}).constructor;function q(n){return n instanceof S}const v=/(^\s*(async\s+)?function\s*(\s|\*)\s*)[A-Za-z_$]+[\w$]*(\s*\()/;function I(n){if(n.name){const t=n.toString();return!v.test(t)}return!0}function G(n){return Array.isArray(n)?n:n==null?[]:[n]}function j(n){for(const[t,r]of Object.entries(n))n[t]=Array.isArray(r)?r:r==null?[]:[r];return n}function p(n,t){return n instanceof Promise?n.then(r=>t(r,!1,void 0),r=>t(void 0,!0,r)):t(n,!1,void 0)}return e.BitFlagEqualTestType=(n=>(n.equal="equal",n.intersect="intersect",n.intersectEqual="intersectEqual",n))(e.BitFlagEqualTestType||{}),(n=>{function t(r){let c;switch(r){case"equal":c=(u,i)=>u===i;case"intersect":c=(u,i)=>u&i;default:c=(u,i)=>(u&i)===u}return c}n.getEqualFun=t})(e.BitFlagEqualTestType||(e.BitFlagEqualTestType={})),e.formatAsArray=G,e.formatMemberAsArray=j,e.getExactTypeNameOf=A,e.getExactTypeOf=a,e.getNameOfType=s,e.getTypeByName=y,e.getTypeNameOf=l,e.getTypeOf=o,e.isAnonymousFunction=I,e.isArrayLike=T,e.isArrowFunction=d,e.isAsyncFunction=E,e.isAsyncGeneratorFunction=q,e.isBaseType=g,e.isGeneratorFunction=N,e.isIdentifier=O,e.isIterable=m,e.isIterator=F,e.isObject=f,e.waitAsyncable=p,Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),e}({});

package/dist/type-tls.js

@@ -23,17 +23,17 @@ function s(n) {
       return t;
   }
 }
-function b(n) {
+function m(n) {
   return globalThis[n];
 }
-function h(n) {
+function F(n) {
   let t = i(n);
   return s(t);
 }
 function a(n) {
   return n == null || f(n) ? i(n) : typeof n;
 }
-function m(n) {
+function h(n) {
   var t = a(n);
   return s(t);
 }
@@ -45,58 +45,66 @@ function $(n) {
   let t = n && n.length;
   return Number.isInteger(n.length) && t >= 0;
 }
-function d(n) {
+function O(n) {
   return n && typeof n[Symbol.iterator] == "function";
 }
-function v(n) {
+function T(n) {
   return n && typeof n.next == "function";
 }
-const l = /^[A-Za-z_$]+[\w$]*$/;
-function T(n) {
-  return l.test(n);
+const y = /^[A-Za-z_$]+[\w$]*$/;
+function d(n) {
+  return y.test(n);
 }
-const y = /(^\s*(async\s+)?\s*(\b[A-Za-z_$]+[\w$]*\b)\s*=>)|(^\s*(async\s+)?\s*\(\s*(\b[A-Za-z_$]+[\w$]*\b)?\s*(,\s*(\b[A-Za-z_$]+[\w$]*\b)\s*)*\)\s*=>)/;
-function O(n) {
+const l = /(^\s*(async\s+)?\s*(\b[A-Za-z_$]+[\w$]*\b)\s*=>)|(^\s*(async\s+)?\s*\(\s*(\b[A-Za-z_$]+[\w$]*\b)?\s*(,\s*(\b[A-Za-z_$]+[\w$]*\b)\s*)*\)\s*=>)/;
+function v(n) {
   const t = n.toString();
-  return y.test(t);
+  return l.test(t);
 }
-const p = globalThis.AsyncFunction ?? (async function() {
+const A = globalThis.AsyncFunction ?? (async function() {
 }).constructor;
 function S(n) {
-  return n instanceof p;
+  return n instanceof A;
 }
-const g = globalThis.GeneratorFunction ?? (function* () {
+const p = globalThis.GeneratorFunction ?? (function* () {
 }).constructor;
 function q(n) {
-  return n instanceof g;
+  return n instanceof p;
 }
-const A = globalThis.AsyncGeneratorFunction ?? (async function* () {
+const g = globalThis.AsyncGeneratorFunction ?? (async function* () {
 }).constructor;
 function x(n) {
-  return n instanceof A;
+  return n instanceof g;
 }
-const F = /(^\s*(async\s+)?function\s*(\s|\*)\s*)[A-Za-z_$]+[\w$]*(\s*\()/;
+const b = /(^\s*(async\s+)?function\s*(\s|\*)\s*)[A-Za-z_$]+[\w$]*(\s*\()/;
 function E(n) {
   if (n.name) {
     const t = n.toString();
-    return !F.test(t);
+    return !b.test(t);
   }
   return !0;
 }
-function G(n, t) {
-  return n instanceof Promise ? n.then((r) => t(r, !1, void 0), (r) => t(void 0, !0, r)) : t(n, !1, void 0);
+function G(n) {
+  return Array.isArray(n) ? n : n == null ? [] : [n];
+}
+function I(n) {
+  for (const [t, e] of Object.entries(n))
+    n[t] = Array.isArray(e) ? e : e == null ? [] : [e];
+  return n;
+}
+function N(n, t) {
+  return n instanceof Promise ? n.then((e) => t(e, !1, void 0), (e) => t(void 0, !0, e)) : t(n, !1, void 0);
 }
 var c = /* @__PURE__ */ ((n) => (n.equal = "equal", n.intersect = "intersect", n.intersectEqual = "intersectEqual", n))(c || {});
 ((n) => {
-  function t(r) {
+  function t(e) {
     let o;
-    switch (r) {
+    switch (e) {
       case "equal":
-        o = (e, u) => e === u;
+        o = (r, u) => r === u;
       case "intersect":
-        o = (e, u) => e & u;
+        o = (r, u) => r & u;
       default:
-        o = (e, u) => (e & u) === e;
+        o = (r, u) => (r & u) === r;
     }
     return o;
   }
@@ -104,22 +112,24 @@ var c = /* @__PURE__ */ ((n) => (n.equal = "equal", n.intersect = "intersect", n
 })(c || (c = {}));
 export {
   c as BitFlagEqualTestType,
-  m as getExactTypeNameOf,
+  G as formatAsArray,
+  I as formatMemberAsArray,
+  h as getExactTypeNameOf,
   a as getExactTypeOf,
   s as getNameOfType,
-  b as getTypeByName,
-  h as getTypeNameOf,
+  m as getTypeByName,
+  F as getTypeNameOf,
   i as getTypeOf,
   E as isAnonymousFunction,
   $ as isArrayLike,
-  O as isArrowFunction,
+  v as isArrowFunction,
   S as isAsyncFunction,
   x as isAsyncGeneratorFunction,
   w as isBaseType,
   q as isGeneratorFunction,
-  T as isIdentifier,
-  d as isIterable,
-  v as isIterator,
+  d as isIdentifier,
+  O as isIterable,
+  T as isIterator,
   f as isObject,
-  G as waitAsyncable
+  N as waitAsyncable
 };

package/dist/type-tls.umd.cjs

@@ -1 +1 @@
-(function(t,i){typeof exports=="object"&&typeof module<"u"?i(exports):typeof define=="function"&&define.amd?define(["exports"],i):(t=typeof globalThis<"u"?globalThis:t||self,i(t.TypeTls={}))})(this,function(t){"use strict";function i(n){var e=typeof n;return n&&(e==="object"||e==="function")}function s(n){var e=n;return n!=null&&(e=n.constructor,e==null&&(e=typeof n)),e}function f(n){switch(n){case void 0:return"undefined";case null:return"null"}let e=typeof n;switch(e){case"function":return n.name;case"string":return n;default:return e}}function y(n){return globalThis[n]}function l(n){let e=s(n);return f(e)}function a(n){return n==null||i(n)?s(n):typeof n}function g(n){var e=a(n);return f(e)}function T(n){var e=typeof n;return n==null||e!=="object"&&e!=="function"}function d(n){let e=n&&n.length;return Number.isInteger(n.length)&&e>=0}function F(n){return n&&typeof n[Symbol.iterator]=="function"}function A(n){return n&&typeof n.next=="function"}const b=/^[A-Za-z_$]+[\w$]*$/;function m(n){return b.test(n)}const p=/(^\s*(async\s+)?\s*(\b[A-Za-z_$]+[\w$]*\b)\s*=>)|(^\s*(async\s+)?\s*\(\s*(\b[A-Za-z_$]+[\w$]*\b)?\s*(,\s*(\b[A-Za-z_$]+[\w$]*\b)\s*)*\)\s*=>)/;function O(n){const e=n.toString();return p.test(e)}const h=globalThis.AsyncFunction??(async function(){}).constructor;function w(n){return n instanceof h}const E=globalThis.GeneratorFunction??(function*(){}).constructor;function $(n){return n instanceof E}const v=globalThis.AsyncGeneratorFunction??(async function*(){}).constructor;function N(n){return n instanceof v}const S=/(^\s*(async\s+)?function\s*(\s|\*)\s*)[A-Za-z_$]+[\w$]*(\s*\()/;function q(n){if(n.name){const e=n.toString();return!S.test(e)}return!0}function I(n,e){return n instanceof Promise?n.then(r=>e(r,!1,void 0),r=>e(void 0,!0,r)):e(n,!1,void 0)}t.BitFlagEqualTestType=(n=>(n.equal="equal",n.intersect="intersect",n.intersectEqual="intersectEqual",n))(t.BitFlagEqualTestType||{}),(n=>{function e(r){let o;switch(r){case"equal":o=(u,c)=>u===c;case"intersect":o=(u,c)=>u&c;default:o=(u,c)=>(u&c)===u}return o}n.getEqualFun=e})(t.BitFlagEqualTestType||(t.BitFlagEqualTestType={})),t.getExactTypeNameOf=g,t.getExactTypeOf=a,t.getNameOfType=f,t.getTypeByName=y,t.getTypeNameOf=l,t.getTypeOf=s,t.isAnonymousFunction=q,t.isArrayLike=d,t.isArrowFunction=O,t.isAsyncFunction=w,t.isAsyncGeneratorFunction=N,t.isBaseType=T,t.isGeneratorFunction=$,t.isIdentifier=m,t.isIterable=F,t.isIterator=A,t.isObject=i,t.waitAsyncable=I,Object.defineProperty(t,Symbol.toStringTag,{value:"Module"})});
+(function(t,i){typeof exports=="object"&&typeof module<"u"?i(exports):typeof define=="function"&&define.amd?define(["exports"],i):(t=typeof globalThis<"u"?globalThis:t||self,i(t.TypeTls={}))})(this,function(t){"use strict";function i(n){var e=typeof n;return n&&(e==="object"||e==="function")}function s(n){var e=n;return n!=null&&(e=n.constructor,e==null&&(e=typeof n)),e}function f(n){switch(n){case void 0:return"undefined";case null:return"null"}let e=typeof n;switch(e){case"function":return n.name;case"string":return n;default:return e}}function y(n){return globalThis[n]}function l(n){let e=s(n);return f(e)}function a(n){return n==null||i(n)?s(n):typeof n}function A(n){var e=a(n);return f(e)}function g(n){var e=typeof n;return n==null||e!=="object"&&e!=="function"}function T(n){let e=n&&n.length;return Number.isInteger(n.length)&&e>=0}function m(n){return n&&typeof n[Symbol.iterator]=="function"}function b(n){return n&&typeof n.next=="function"}const F=/^[A-Za-z_$]+[\w$]*$/;function d(n){return F.test(n)}const O=/(^\s*(async\s+)?\s*(\b[A-Za-z_$]+[\w$]*\b)\s*=>)|(^\s*(async\s+)?\s*\(\s*(\b[A-Za-z_$]+[\w$]*\b)?\s*(,\s*(\b[A-Za-z_$]+[\w$]*\b)\s*)*\)\s*=>)/;function h(n){const e=n.toString();return O.test(e)}const p=globalThis.AsyncFunction??(async function(){}).constructor;function w(n){return n instanceof p}const E=globalThis.GeneratorFunction??(function*(){}).constructor;function $(n){return n instanceof E}const N=globalThis.AsyncGeneratorFunction??(async function*(){}).constructor;function S(n){return n instanceof N}const q=/(^\s*(async\s+)?function\s*(\s|\*)\s*)[A-Za-z_$]+[\w$]*(\s*\()/;function I(n){if(n.name){const e=n.toString();return!q.test(e)}return!0}function j(n){return Array.isArray(n)?n:n==null?[]:[n]}function v(n){for(const[e,r]of Object.entries(n))n[e]=Array.isArray(r)?r:r==null?[]:[r];return n}function G(n,e){return n instanceof Promise?n.then(r=>e(r,!1,void 0),r=>e(void 0,!0,r)):e(n,!1,void 0)}t.BitFlagEqualTestType=(n=>(n.equal="equal",n.intersect="intersect",n.intersectEqual="intersectEqual",n))(t.BitFlagEqualTestType||{}),(n=>{function e(r){let c;switch(r){case"equal":c=(u,o)=>u===o;case"intersect":c=(u,o)=>u&o;default:c=(u,o)=>(u&o)===u}return c}n.getEqualFun=e})(t.BitFlagEqualTestType||(t.BitFlagEqualTestType={})),t.formatAsArray=j,t.formatMemberAsArray=v,t.getExactTypeNameOf=A,t.getExactTypeOf=a,t.getNameOfType=f,t.getTypeByName=y,t.getTypeNameOf=l,t.getTypeOf=s,t.isAnonymousFunction=I,t.isArrayLike=T,t.isArrowFunction=h,t.isAsyncFunction=w,t.isAsyncGeneratorFunction=S,t.isBaseType=g,t.isGeneratorFunction=$,t.isIdentifier=d,t.isIterable=m,t.isIterator=b,t.isObject=i,t.waitAsyncable=G,Object.defineProperty(t,Symbol.toStringTag,{value:"Module"})});

package/dist/vector.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 二维向量
+ */
+export interface IVector2 {
+    x: number;
+    y: number;
+}
+/**
+ * 三维向量
+ */
+export interface IVector3 extends IVector2 {
+    z: number;
+}
+/**
+ * 四维向量
+ */
+export interface IVector4 extends IVector3 {
+    w: number;
+}
+/**
+ * 向量
+ */
+export type IVector = IVector2 | IVector3 | IVector4;

package/doc/api/type-tls.md

@@ -45,6 +45,28 @@ Description
 </th></tr></thead>
 <tbody><tr><td>
 
+[formatAsArray(value)](./type-tls.formatasarray.md)
+
+
+</td><td>
+
+格式化为数组格式
+
+
+</td></tr>
+<tr><td>
+
+[formatMemberAsArray(data)](./type-tls.formatmemberasarray.md)
+
+
+</td><td>
+
+格式化对象成员为数组格式
+
+
+</td></tr>
+<tr><td>
+
 [getExactTypeNameOf(inst)](./type-tls.getexacttypenameof.md)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-tls",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "description": "type-tls 封装了与类型相关的工具，比如:获取数据的类型 或 类型名字、判断数据的类型 等",
   "main": "./dist/type-tls.umd.cjs",
   "module": "./dist/type-tls.js",

package/dist/tsdoc-metadata.json

@@ -1,11 +0,0 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.52.7"
-    }
-  ]
-}

package/dist/type-tls.d.ts

@@ -1,445 +0,0 @@
-/**
- * 表示任意的函数类型
- */
-export declare type AnyFunction = (...args: any) => any;
-
-/**
- * 获取数组元素的类型
- * @typeParam Arr 数组
- */
-export declare type ArrayItemType<Arr> = Arr extends (infer Item)[] ? Item : never;
-
-/**
- * 位标志相等测试
- */
-export declare enum BitFlagEqualTestType {
-    /**
-     * 相等:A === B
-     */
-    equal = "equal",// "相等"
-    /**
-     * 相交:A & B
-     */
-    intersect = "intersect",// "相交"
-    /**
-     * 交等:A & B === A
-     */
-    intersectEqual = "intersectEqual"
-}
-
-export declare namespace BitFlagEqualTestType {
-    /**
-     * 获取 位标志相等测试的函数
-     * @param testType 默认 intersectEqual
-     * @returns
-     */
-    export function getEqualFun(testType?: BitFlagEqualTestType | null): (a: number, b: number) => number | boolean;
-}
-
-/**
- * 精确类型
- *
- * @remarks
- * 在精准类型中认为 JavaScript 的原始类型（非对象类型） 与 其对应的 包装类型（类类型）是不同的类型，即：
- * number 和  Number、string 和 String、boolean 和 Boolean 等 是不同的类型；
- * 对于原始类型，返回的结果 会与 typeof 返回的结果一样；
- * 但，对于 undefined 和 null 会返回其自身值（即 undefined 和 null）作为类型值
- *
- * 各种类型的值 与 该方法的返回值 的映射如下：
- * ```
- * undefined ：undefined
- * null : null
- * string : "string"
- * number : "number"
- * bigint : "bigint"
- * boolean : "boolean"
- * symbol : "symbol"
- * function : Function
- * 没有原型的对象(如：通过 `Object.create(null)` 创建的对象) : "object"
- * 其它任何类型的实例  : 返回该实例的构造函数
- * ```
- */
-export declare type ExactType = LooseType | Exclude<TypeOfReturnType, "undefined" | "function" | "object">;
-
-/**
- * 精确类型的字符串表示
- *
- * @remarks
- * 在精准类型中认为 JavaScript 的原始类型（非对象类型） 与 其对应的 包装类型（类类型）是不同的类型，即：
- * number 和  Number、string 和 String、boolean 和 Boolean 等 是不同的类型；
- * 对于原始类型，返回的结果 会与 typeof 返回的结果一样；
- * 但，对于 null 会返回 "null"
- *
- * 各种类型的值 与 该方法的返回值 的映射如下：
- * ```
- * undefined ："undefined"
- * null : "null"
- * function : "Function"
- * string : "string"
- * number : "number"
- * bigint : "bigint"
- * boolean : "boolean"
- * symbol : "symbol"
- * 没有原型的对象(如：通过 Object.create(null) 创建的对象) : "object"
- * 其它任何类型的实例  : 返回该实例的构造函数的名字
- * ```
- */
-export declare type ExactTypeName = LooseTypeName | Exclude<TypeOfReturnType, "undefined" | "function" | "object">;
-
-/**
- * 格式化为数组格式
- * @remarks
- * 如果 ItemOrArray 是数组，则保持不变
- * 如果  ItemOrArray 不是数组，则转为数组类型 ItemOrArray[]
- */
-export declare type FormatAsArray<ItemOrArray> = ItemOrArray extends any[] ? ItemOrArray : ItemOrArray[];
-
-/**
- * 格式化对象成员为数组格式
- * @remarks
- * 如果 成员 是数组，则保持不变
- * 如果  成员 不是数组，则转为数组类型
- */
-export declare type FormatMemberAsArray<D> = {
-    [K in keyof D]: FormatAsArray<D[K]>;
-};
-
-/**
- * 获取 inst 的精确类型的字符串表示
- * @param inst
- * @returns  inst 的类型字符串
- */
-export declare function getExactTypeNameOf(inst: any): ExactTypeName;
-
-/**
- * 获取 inst 的精确类型
- * @param inst
- * @returns inst 的类型
- */
-export declare function getExactTypeOf(inst: any): ExactType;
-
-/**
- * 获取 类型的字符串表示
- *
- * @param t - 一个 ExactType 类型的值
- * @return t 的字符串表示的类型
- */
-export declare function getNameOfType(t: ExactType): ExactTypeName;
-
-/**
- * 根据类型的名字获取其对应的类
- * @param typeName - 类型的名字
- */
-export declare function getTypeByName(typeName: string): Function | undefined;
-
-/**
- * 获取 inst 的类型字符串
- *
- * @remarks
- * 注意：
- * 本方法返回的结果如下：
- * undefined ："undefined"
- * null ： "null"
- * 没有原型的对象(如：通过 Object.create(null) 创建的对象) : "object"
- * 其它任何类型的实例  : 返回该实例的构造函数  或 包装对象的构造函数 的函数名字
- *
- * @param inst
- * @returns  inst 的类型字符串
- */
-export declare function getTypeNameOf(inst: any): LooseTypeName;
-
-/**
- * 获取 inst 的宽松类型
- *
- * @remarks
- * 注意：
- * 本方法返回的结果如下：
- * ```
- * undefined ：undefined
- * null ： null
- * function : Function
- * 没有原型的对象(如：通过 Object.create(null) 创建的对象) : "object"
- * 其它任何类型的实例  : 返回该实例的构造函数  或 包装对象的构造函数
- * ```
- *
- *
- * @param inst
- * @returns inst 的类型
- */
-export declare function getTypeOf(inst: any): LooseType;
-
-/**
- * 判断是否是匿名函数
- *
- * @remarks
- * 判断函数在被定义时是否是通过匿名函数来定义的。
- * 匿名函数是指声明函数时没有写名字的函数。
- * 注意：即使是匿名函数，函数对象上的 name 属性也可能是有值的，因为 js解析器 会自动将 函数表达式函数变量的名字作为匿名函数的名字，如下：
- * ```ts
- * var funName = function(){};
- * ```
- * 其中的匿名函数对象的 name 属性的值会是 `funName`
- *
- * 如果 函数对象上的 name 属性的值为 `""`，函数一定是匿名函数。
- */
-export declare function isAnonymousFunction(fun: Function): boolean;
-
-/**
- * 判断 target 是否为 类数组对象
- * @param target  -  目标
- * @returns
- */
-export declare function isArrayLike(target: any): boolean;
-
-/**
- * 判断函数是否是箭头函数
- * @param fun - 被判断的函数
- */
-export declare function isArrowFunction(fun: Function): boolean;
-
-/**
- * 判断函数是否是 async 异步函数
- * @remarks
- * 异步函数 不包含 异步生成器函数 AsyncGeneratorFunction
- * @param fun - 被判断的函数
- */
-export declare function isAsyncFunction(fun: Function): boolean;
-
-/**
- * 判断函数是否是异步生成器函数
- * @param fun - 被判断的函数
- */
-export declare function isAsyncGeneratorFunction(fun: Function): boolean;
-
-/**
- * 判断 data 是否是 基本类型
- * @remarks
- * 基本类型 是指 那些不是 对象类型的类型，即，除了 object 和 function  类型以外，其它的都是基本类型，null 也算怎是 基本类型
- * @param data - 任意类型的值
- */
-export declare function isBaseType(data: any): boolean;
-
-/**
- * 判断函数是否是生成器函数
- *
- * @remarks
- * 生成器函数 不包含 异步生成器函数 AsyncGeneratorFunction
- * @param fun - 被判断的函数
- */
-export declare function isGeneratorFunction(fun: Function): boolean;
-
-/**
- * 判断 code 是否是有校的 js 标识符
- * @param code - 标识符的字符串
- */
-export declare function isIdentifier(code: string): boolean;
-
-/**
- * 判断 目标 是否是可迭代的对象，即 实现了 可迭代协议
- * @param target - 目标
- */
-export declare function isIterable(target: any): boolean;
-
-/**
- * 判断 目标 是否是迭代器，即 实现了 迭代器协议
- * @param target - 目标
- */
-export declare function isIterator(target: any): boolean;
-
-/**
- * 判断目标是否是对象类型
- *
- * @remarks
- * 仅通过 target instanceof Object 判断是不行的，因为 对于 Object.create(null) 创建的对象 通过 ` Object.create(null) instanceof Object ` 来判断 返回的是 false
- * 即：通过 Object.create(null) 创建的对象是不被 instanceof  认为是继续于 Object 的
- *
- * typeof null 也返回 "object"
- *
- * @param target : any   目标对象
- */
-export declare function isObject(target: any): boolean;
-
-/**
- * 获取值类型包含指定类型的所有 key
- *
- * @typeParam Target - 目标对象
- * @typeParam Value - 要获取的key的对应值应包含的类型
- */
-export declare type KeyOfContainsValue<Target, Value> = {
-    [K in keyof Target]: Value extends Target[K] ? K : never;
-}[keyof Target];
-
-/**
- * 获取值类型不应包含指定类型的所有 key
- *
- * @typeParam Target - 目标对象
- * @typeParam Value - 不应包含的值的类型
- */
-export declare type KeyOfNonContainsValue<Target, Value> = {
-    [K in keyof Target]: Value extends Target[K] ? never : K;
-}[keyof Target];
-
-/**
- * 获取值类型不是指定类型的所有 key
- *
- * @typeParam Target - 目标对象
- * @typeParam Value - 被排除的值的类型
- */
-export declare type KeyOfNonValue<Target, Value> = {
-    [K in keyof Target]: Target[K] extends Value ? never : K;
-}[keyof Target];
-
-/**
- * 获取值类型为指定类型的所有 key
- *
- * @typeParam Target - 目标对象
- * @typeParam Value - 要获取的key的对应值的类型
- */
-export declare type KeyOfValue<Target, Value> = {
-    [K in keyof Target]: Target[K] extends Value ? K : never;
-}[keyof Target];
-
-/**
- * 宽松的类型
- */
-export declare type LooseType = undefined | null | Function | "object";
-
-/**
- * 宽松类型的字符串表示
- */
-export declare type LooseTypeName = "undefined" | "null" | "Function" | "object" | string;
-
-/**
- * 获取对象的方法的某个参数的类型
- *
- * @typeParam Obj - 对象
- * @typeParam Method - 对象方法的名字
- * @typeParam ParamIndex - 参数的索引个数
- */
-export declare type MethodParams<Obj, Method extends keyof Obj, ParamIndex extends number> = Obj[Method] extends AnyFunction ? Parameters<Obj[Method]>[ParamIndex] : never;
-
-/**
- * 获取对象的方法的返回的类型
- *
- * @typeParam Obj - 对象
- * @typeParam Method - 对象方法的名字
- */
-export declare type MethodReturnType<Obj, Method extends keyof Obj> = Obj[Method] extends AnyFunction ? ReturnType<Obj[Method]> : never;
-
-/**
- * 将某个类型变为可选的类型
- */
-export declare type Optional<T> = T | null | undefined;
-
-/**
- * 可选的布尔类型
- */
-export declare type OptionalBoolean = Optional<boolean>;
-
-/**
- * 从 Target 中挑选出那些成员值的类型包含 Value 类型的成员
- */
-export declare type PickContainsValue<Target, Value> = {
-    [P in KeyOfContainsValue<Target, Value>]: Target[P];
-};
-
-/**
- * 从 Target 中挑选出方法
- */
-export declare type PickMethod<Target> = PickValue<Target, AnyFunction>;
-
-/**
- * 从 Target 中挑选出那些成员值的类型不包含 Value 类型的成员
- */
-export declare type PickNonContainsValue<Target, Value> = {
-    [P in KeyOfNonContainsValue<Target, Value>]: Target[P];
-};
-
-/**
- * 从 Target 中挑选出那些成员值不是 Value 的类型的成员
- */
-export declare type PickNonValue<Target, Value> = {
-    [P in KeyOfNonValue<Target, Value>]: Target[P];
-};
-
-/**
- * 从 Target 中挑选出属性
- */
-export declare type PickProperty<Target> = PickNonValue<Target, AnyFunction>;
-
-/**
- * 从 T 中挑选出那些成员值为 Value 的类型的成员
- */
-export declare type PickValue<Target, Value> = {
-    [P in KeyOfValue<Target, Value>]: Target[P];
-};
-
-/**
- * 可将源类型 SourType 中的 类型 MatchType 替换为 新的类型 NewType
- */
-export declare type Replace<SourType, MatchType, NewType> = SourType extends MatchType ? NewType : SourType;
-
-/**
- * 可将源类型 SourType 中的 null 替换为 新的类型 NewType
- */
-export declare type ReplaceNull<SourType, NewType> = Replace<SourType, null, NewType>;
-
-/**
- * 可将源类型 SourType 中的 undefined 替换为 新的类型 NewType
- */
-export declare type ReplaceUndefined<SourType, NewType> = Replace<SourType, undefined, NewType>;
-
-/**
- * 可将源类型 SourType 中的代表空的类型 void | undefined | null 替换为 新的类型 NewType
- */
-export declare type ReplaceVoid<SourType, NewType> = Replace<SourType, void | undefined | null, NewType>;
-
-/**
- * 获取 Promise 解决的类型的值
- * @remarks
- * 对于非 Promise 类型的值，返回原类型本身
- */
-export declare type ResolveData<P> = P extends Promise<infer D> ? D : P;
-
-/**
- * 将 T 及其对象成员属性值都改为 Partial 类型
- * @remarks
- * 比 Partial 又深入的一层
- */
-export declare type TwoLayerPartial<T> = {
-    [P in keyof T]?: Partial<T[P]>;
-};
-
-export declare type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array | Float32Array | Float64Array;
-
-/**
- * typeof 的返回类型
- */
-export declare type TypeOfReturnType = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-
-/**
- * 等待可异步的结果
- *
- * @remarks
- * 当 asyncable 为同步值时，会同步调用 callback。
- * 当 asyncable 为异步值时，会等待 asyncable 解决后再调用 callback。
- *
- * @param asyncable - 可异步的结果
- * @param callback
- * @returns
- */
-export declare function waitAsyncable<Result, Return>(asyncable: Result, callback: WaitAsyncableCallback<Result, Return>): WaitAsyncableReturn<Result, Return>;
-
-/**
- * waitAsyncable 的回调函数的类型
- * @param result -  同步的结果
- * @param rejected - 异步是否被拒绝
- */
-export declare type WaitAsyncableCallback<Result, Return> = (result: ResolveData<Result> | undefined, rejected: boolean, error: any) => Return;
-
-/**
- * waitAsyncable 的返回值的类型
- */
-export declare type WaitAsyncableReturn<Result, Return> = Return extends Promise<any> ? Return : (Result extends Promise<any> ? Promise<Return> : Return);
-
-export { }