type-tls 2.2.1 → 2.4.1

package/dist/type-tls.d.ts

@@ -1,10 +1,98 @@
 /**
- * 处理类型相关的工具
+ * 表示任意的函数类型
+ */
+export declare type AnyFunction = (...args: any) => any;
+
+/**
+ * 类的类型、构造函数的类型
+ *
+ * @typeParam Arg - 构建函数的参数类型
+ * @typeParam Instance - 构建函数的返回的实例类型
+ */
+export declare interface ClassType<Arg extends any[] = any[], Instance = any> {
+    new (...args: Arg): Instance;
+}
+
+/**
+ * 创建定义混合的类型便利函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link defineMixin} 的功能一样，唯一区别是不再需要接收 target 参数了
+ *
+ * @returns 可以用于 定义混合的 类型便利函数
+ */
+export declare function createDefineMixin<T>(): <M>(target: T, mixin: M & ThisType<T & M>) => M & ThisType<T & M>;
+
+/**
+ * 创建用于扩展目标工具函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link extendTarget} 的功能一样，唯一区别是不再需要接收 cla 参数了
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @returns 可以用于 扩展目标 的便利函数
+ */
+export declare function createExtendTarget<C extends ClassType>(cla: C): <E>(ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>) => ClassType<ConstructorParameters<C>, E & ThisType<InstanceType<C> & E>>;
+
+/**
+ * 创建用于混合目标工具函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link mixinTarget} 的功能一样，唯一区别是不再需要接收 target 参数了
+ *
+ * @returns 可以用于 混合目标 的便利函数
+ */
+export declare function createMixinTarget<T>(target: T): <M>(m: M & ThisType<T & M>) => M & ThisType<T & M> & T;
+
+/**
+ * 创建用于扩展目标的便捷函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link targetExtend} 的功能一样，唯一区别是不再需要接收 cla 参数了
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @returns 可以用于 扩展目标 的便利函数
+ */
+export declare function createTargetExtend<C extends ClassType>(cla: C): <E>(ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>) => E & ThisType<C & E>;
+
+/**
+ * 创建用于混合目标的便捷函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link targetMixin} 的功能一样，唯一区别是不再需要接收 target 参数了
+ *
+ * @param target - 混合的目标，用作 this 的类型
+ * @returns 可以用于 混合目标 的便利函数
+ */
+export declare function createTargetMixin<T>(target: T): <M>(m: M & ThisType<T & M>) => M & ThisType<T & M>;
+
+/**
+ * 定义扩展的类型便利函数
+ *
+ * @remarks
+ * 它会更改 ext 中方法的this指向为 cla & ext，不会真的执行扩展操作。
+ *
+ * 其中 ext._constructor  会被保存在 cla._constructors 属性中，它是一个数组。
+ *
+ * cla 需要在自己的构建函数中逐个调用 cla._constructors 中的函数
+ *
+ * @param cla - 扩展的目标，用作 this 的类型
+ * @param ext - 描述扩展内容的对象，会自动更改其this的类型
+ * @returns 返回注入了 this 类型的 ext 对象本身
+ */
+export declare function defineExtend<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>): E & ThisType<C & E>;
+
+/**
+ * 定义混合的类型便利函数
+ *
  * @remarks
- * type-tls 封装了与类型相关的工具，比如获取数据的类型 或 类型名字、判断数据的类型 等
+ * 它会更改 mixin 中方法的this指向为 target & mixin，不会真的执行混合操作
  *
- * @packageDocumentation
+ * @param target - 混合的目标，用作 this 的类型
+ * @param mixin - 混合对象，会自动更改其this的类型
+ * @returns 返回注入了 this 类型的 mixin 对象本身
  */
+export declare function defineMixin<T, M>(target: T, mixin: M & ThisType<T & M>): M & ThisType<T & M>;
 
 /**
  * 精确类型
@@ -56,6 +144,19 @@ export declare type ExactType = LooseType | Exclude<TypeOfReturnType, "undefined
  */
 export declare type ExactTypeName = LooseTypeName | Exclude<TypeOfReturnType, "undefined" | "function" | "object">;
 
+/**
+ * 扩展目标
+ *
+ * @remarks
+ * 会执行对 CEarth 类的扩展操作。
+ * 与 {@link targetExtend} 的区别仅仅是返回类型不一样。
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @param ext - 扩展对象，会自动更改其this的类型
+ * @returns 返回扩展后的 cla 对象
+ */
+export declare function extendTarget<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>): ClassType<ConstructorParameters<C>, E & ThisType<InstanceType<C> & E>>;
+
 /**
  * 获取 inst 的精确类型的字符串表示
  * @param inst
@@ -120,6 +221,22 @@ export declare function getTypeNameOf(inst: any): LooseTypeName;
  */
 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  -  目标
@@ -127,6 +244,26 @@ export declare function getTypeOf(inst: any): LooseType;
  */
 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
@@ -135,6 +272,21 @@ export declare function isArrayLike(target: any): boolean;
  */
 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 - 目标
@@ -170,6 +322,74 @@ 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;
+
+/**
+ * 混合
+ * @internal
+ */
+export declare function mixin<T, S>(target: T, source: S): T & S;
+
+/**
+ * 混合
+ * @internal
+ */
+export declare function mixin<T, S1, S2>(target: T, source1: S1, source2: S2): T & S1 & S2;
+
+/**
+ * 混合
+ * @internal
+ */
+export declare function mixin<T, S1, S2, S3>(target: T, source1: S1, source2: S2, source3: S3): T & S1 & S2 & S3;
+
+/**
+ * 混合
+ * @internal
+ */
+export declare function mixin<T, S1, S2, S3, S4>(target: T, source1: S1, source2: S2, source3: S3, source4: S3): T & S1 & S2 & S3 & S4;
+
+/**
+ * 混合
+ *
+ * @remarks
+ * 将 source 的所有成员混入 target 对象中。
+ *
+ * 与 `Object.assign()` 的功能类似，不同的是 `mixin()` 会在 target 对象中 保持 source 对象属性的  PropertyDescriptors
+ *
+ * @param target - 目标对象，所有 源对象 的属性都要被混入进到 目标对象中
+ * @param sources - 源对象，所有 源对象 的属性都要被混入进到 目标对象中
+ * @returns 混入后的 target
+ */
+export declare function mixin(target: any, ...sources: any[]): any;
+
+/**
+ * 混合目标
+ *
+ * @remarks
+ * 会执行对 CEarth 类的扩展操作。
+ * 与 {@link targetMixin} 的区别仅仅是返回类型不一样。
+ *
+ * @param target - 混合的目标，用作 this 的类型
+ * @param m - 混合对象，会自动更改其this的类型
+ * @returns 返回混合后的 target 对象
+ */
+export declare function mixinTarget<T, M>(target: T, m: M & ThisType<T & M>): M & ThisType<T & M> & T;
+
 /**
  * 将某个类型变为可选的类型
  */
@@ -180,6 +400,25 @@ export declare type Optional<T> = T | null | undefined;
  */
 export declare type OptionalBoolean = Optional<boolean>;
 
+/**
+ * 用于定义扩展选项中的私有成员
+ */
+export declare interface PrivateMemberOfExtend<TargetType extends new (...args: any) => any> {
+    /**
+     * 扩展类中用于定义在创建实例时的初始化的方法
+     * @remarks
+     * 该方法会在创建实例时自动执行，并将构建函数接收到的参数透传给方方法。
+     *
+     * 注意：
+     * _constructor  会被保存在 目标类中的 _constructors 属性中，它是一个数组。
+     *
+     * 目标类 需要在自己的构建函数中逐个调用 cla._constructors 中的函数
+     *
+     * @param args
+     */
+    _constructor?: (...args: (TargetType extends new (...args: infer A) => any ? A : never)) => void;
+}
+
 /**
  * 可将源类型 SourType 中的 类型 MatchType 替换为 新的类型 NewType
  */
@@ -200,9 +439,70 @@ export declare type ReplaceUndefined<SourType, NewType> = Replace<SourType, unde
  */
 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;
+
+/**
+ * 扩展目标
+ *
+ * @remarks
+ * 与 {@link defineExtend} 的区别是：`targetExtend` 会执行对 cla 的扩展操作，而 {@link defineExtend} 不会
+ *
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @param ext - 扩展描述对象，会自动更改其this的类型
+ * @returns 返回注入了 this 类型的 ext 对象本身
+ */
+export declare function targetExtend<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>): E & ThisType<InstanceType<C> & E>;
+
+/**
+ * 混合目标
+ *
+ * @remarks
+ * 与 {@link defineMixin} 的区别是：`targetMixin` 会执行对 target 的混合操作，而 {@link defineMixin} 不会
+ *
+ *
+ * @param target - 混合的目标，用作 this 的类型
+ * @param m - 混合对象，会自动更改其this的类型
+ * @returns 返回注入了 this 类型的 mixin 对象本身
+ */
+export declare function targetMixin<T, M>(target: T, m: M & ThisType<T & M>): M & ThisType<T & M>;
+
 /**
  * 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 interface WaitAsyncableCallback<Result, Return> {
+    (result: ResolveData<Result>, rejected: false): Return;
+    (result: undefined, rejected: true, reason: any): Return;
+}
+
+/**
+ * waitAsyncable 的返回值的类型
+ */
+export declare type WaitAsyncableReturn<Result, Return> = Return extends Promise<any> ? Return : (Result extends Promise<any> ? Promise<Return> : Return);
+
 export { }

package/dist/type-tls.es.js

@@ -1,3 +1,4 @@
+var _a, _b, _c;
 function isObject(target) {
   var tarType = typeof target;
   return target && (tarType === "object" || tarType === "function");
@@ -60,4 +61,111 @@ function isIterable(target) {
 function isIterator(target) {
   return target && typeof target.next === "function";
 }
-export { getExactTypeNameOf, getExactTypeOf, getNameOfType, getTypeByName, getTypeNameOf, getTypeOf, isArrayLike, isBaseType, isIterable, isIterator, isObject };
+function mixin(target, ...sources) {
+  for (const s of sources) {
+    const propDes = Object.getOwnPropertyDescriptors(s);
+    Object.defineProperties(target, propDes);
+  }
+  return target;
+}
+function defineMixin(target, mixin2) {
+  return mixin2;
+}
+function createDefineMixin() {
+  return function defineMixin2(target, mixin2) {
+    return mixin2;
+  };
+}
+function targetMixin(target, m) {
+  mixin(target, m);
+  return m;
+}
+function createTargetMixin(target) {
+  return function targetMixin2(m) {
+    mixin(target, m);
+    return m;
+  };
+}
+function mixinTarget(target, m) {
+  mixin(target, m);
+  return target;
+}
+function createMixinTarget(target) {
+  return function mixinTarget2(m) {
+    mixin(target, m);
+    return target;
+  };
+}
+function defineExtend(cla, ext) {
+  return ext;
+}
+function targetExtend(cla, ext) {
+  var _a2;
+  mixin(cla.prototype, ext);
+  const _constructor = ext._constructor;
+  if (typeof _constructor === "function") {
+    const target = cla;
+    const _constructors = (_a2 = target._constructors) != null ? _a2 : target._constructors = [];
+    _constructors.push(_constructor);
+  }
+  return ext;
+}
+function createTargetExtend(cla) {
+  return function classExtend(ext) {
+    targetExtend(cla, ext);
+    return ext;
+  };
+}
+function extendTarget(cla, ext) {
+  targetExtend(cla, ext);
+  return cla;
+}
+function createExtendTarget(cla) {
+  return function extendTarget2(ext) {
+    targetExtend(cla, ext);
+    return cla;
+  };
+}
+const jsIdentifier = /^[A-Za-z_$]+[\w$]*$/;
+function isIdentifier(code) {
+  return jsIdentifier.test(code);
+}
+const arrowFunctionRegExpOfFunString = /(^\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 isArrowFunction(fun) {
+  const funStr = fun.toString();
+  return arrowFunctionRegExpOfFunString.test(funStr);
+}
+const AsyncFun = (_a = globalThis.AsyncFunction) != null ? _a : async function() {
+}.constructor;
+function isAsyncFunction(fun) {
+  return fun instanceof AsyncFun;
+}
+const GeneratorFun = (_b = globalThis.GeneratorFunction) != null ? _b : function* () {
+}.constructor;
+function isGeneratorFunction(fun) {
+  return fun instanceof GeneratorFun;
+}
+const AsyncGeneratorFun = (_c = globalThis.AsyncGeneratorFunction) != null ? _c : async function* () {
+}.constructor;
+function isAsyncGeneratorFunction(fun) {
+  return fun instanceof AsyncGeneratorFun;
+}
+const funNameRegExpOfFunString = /(^\s*(async\s+)?function\s*(\s|\*)\s*)[A-Za-z_$]+[\w$]*(\s*\()/;
+function isAnonymousFunction(fun) {
+  if (fun.name) {
+    const funStr = fun.toString();
+    return !funNameRegExpOfFunString.test(funStr);
+  }
+  return true;
+}
+function waitAsyncable(asyncable, callback) {
+  if (asyncable instanceof Promise) {
+    return asyncable.then((syncRes) => {
+      return callback(syncRes, false);
+    }, (reason) => {
+      return callback(void 0, true, reason);
+    });
+  }
+  return callback(asyncable, false);
+}
+export { createDefineMixin, createExtendTarget, createMixinTarget, createTargetExtend, createTargetMixin, defineExtend, defineMixin, extendTarget, getExactTypeNameOf, getExactTypeOf, getNameOfType, getTypeByName, getTypeNameOf, getTypeOf, isAnonymousFunction, isArrayLike, isArrowFunction, isAsyncFunction, isAsyncGeneratorFunction, isBaseType, isGeneratorFunction, isIdentifier, isIterable, isIterator, isObject, mixin, mixinTarget, targetExtend, targetMixin, waitAsyncable };

package/dist/type-tls.iife.js

@@ -1 +1 @@
-var typeTls=function(n){"use strict";function f(e){var t=typeof e;return e&&(t==="object"||t==="function")}function u(e){var t=e;return e!=null&&(t=e.constructor,t==null&&(t=typeof e)),t}function r(e){switch(e){case void 0:return"undefined";case null:return"null"}let t=typeof e;switch(t){case"function":return e.name;case"string":return e;default:return t}}function c(e){return globalThis[e]}function y(e){let t=u(e);return r(t)}function i(e){return e==null||f(e)?u(e):typeof e}function a(e){var t=i(e);return r(t)}function o(e){var t=typeof e;return e==null||t!=="object"&&t!=="function"}function l(e){let t=e&&e.length;return Number.isInteger(e.length)&&t>=0}function T(e){return e&&typeof e[Symbol.iterator]=="function"}function g(e){return e&&typeof e.next=="function"}return n.getExactTypeNameOf=a,n.getExactTypeOf=i,n.getNameOfType=r,n.getTypeByName=c,n.getTypeNameOf=y,n.getTypeOf=u,n.isArrayLike=l,n.isBaseType=o,n.isIterable=T,n.isIterator=g,n.isObject=f,Object.defineProperties(n,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}}),n}({});
+var typeTls=function(e){var y,g,T;"use strict";function a(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 f(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 d(n){return globalThis[n]}function A(n){let t=o(n);return f(t)}function s(n){return n==null||a(n)?o(n):typeof n}function b(n){var t=s(n);return f(t)}function m(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 O(n){return n&&typeof n[Symbol.iterator]=="function"}function E(n){return n&&typeof n.next=="function"}function i(n,...t){for(const r of t){const c=Object.getOwnPropertyDescriptors(r);Object.defineProperties(n,c)}return n}function M(n,t){return t}function w(){return function(t,r){return r}}function _(n,t){return i(n,t),t}function h(n){return function(r){return i(n,r),r}}function $(n,t){return i(n,t),n}function v(n){return function(r){return i(n,r),n}}function N(n,t){return t}function u(n,t){var c;i(n.prototype,t);const r=t._constructor;if(typeof r=="function"){const l=n;((c=l._constructors)!=null?c:l._constructors=[]).push(r)}return t}function S(n){return function(r){return u(n,r),r}}function I(n,t){return u(n,t),n}function j(n){return function(r){return u(n,r),n}}const G=/^[A-Za-z_$]+[\w$]*$/;function p(n){return G.test(n)}const z=/(^\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 Z(n){const t=n.toString();return z.test(t)}const B=(y=globalThis.AsyncFunction)!=null?y:async function(){}.constructor;function D(n){return n instanceof B}const P=(g=globalThis.GeneratorFunction)!=null?g:function*(){}.constructor;function x(n){return n instanceof P}const L=(T=globalThis.AsyncGeneratorFunction)!=null?T:async function*(){}.constructor;function R(n){return n instanceof L}const k=/(^\s*(async\s+)?function\s*(\s|\*)\s*)[A-Za-z_$]+[\w$]*(\s*\()/;function q(n){if(n.name){const t=n.toString();return!k.test(t)}return!0}function C(n,t){return n instanceof Promise?n.then(r=>t(r,!1),r=>t(void 0,!0,r)):t(n,!1)}return e.createDefineMixin=w,e.createExtendTarget=j,e.createMixinTarget=v,e.createTargetExtend=S,e.createTargetMixin=h,e.defineExtend=N,e.defineMixin=M,e.extendTarget=I,e.getExactTypeNameOf=b,e.getExactTypeOf=s,e.getNameOfType=f,e.getTypeByName=d,e.getTypeNameOf=A,e.getTypeOf=o,e.isAnonymousFunction=q,e.isArrayLike=F,e.isArrowFunction=Z,e.isAsyncFunction=D,e.isAsyncGeneratorFunction=R,e.isBaseType=m,e.isGeneratorFunction=x,e.isIdentifier=p,e.isIterable=O,e.isIterator=E,e.isObject=a,e.mixin=i,e.mixinTarget=$,e.targetExtend=u,e.targetMixin=_,e.waitAsyncable=C,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}}),e}({});

package/dist/type-tls.umd.js

@@ -1 +1 @@
-(function(n,u){typeof exports=="object"&&typeof module!="undefined"?u(exports):typeof define=="function"&&define.amd?define(["exports"],u):(n=typeof globalThis!="undefined"?globalThis:n||self,u(n.typeTls={}))})(this,function(n){"use strict";function u(e){var t=typeof e;return e&&(t==="object"||t==="function")}function f(e){var t=e;return e!=null&&(t=e.constructor,t==null&&(t=typeof e)),t}function i(e){switch(e){case void 0:return"undefined";case null:return"null"}let t=typeof e;switch(t){case"function":return e.name;case"string":return e;default:return t}}function o(e){return globalThis[e]}function c(e){let t=f(e);return i(t)}function r(e){return e==null||u(e)?f(e):typeof e}function y(e){var t=r(e);return i(t)}function l(e){var t=typeof e;return e==null||t!=="object"&&t!=="function"}function a(e){let t=e&&e.length;return Number.isInteger(e.length)&&t>=0}function p(e){return e&&typeof e[Symbol.iterator]=="function"}function T(e){return e&&typeof e.next=="function"}n.getExactTypeNameOf=y,n.getExactTypeOf=r,n.getNameOfType=i,n.getTypeByName=o,n.getTypeNameOf=c,n.getTypeOf=f,n.isArrayLike=a,n.isBaseType=l,n.isIterable=p,n.isIterator=T,n.isObject=u,Object.defineProperties(n,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});
+(function(e,r){typeof exports=="object"&&typeof module!="undefined"?r(exports):typeof define=="function"&&define.amd?define(["exports"],r):(e=typeof globalThis!="undefined"?globalThis:e||self,r(e.typeTls={}))})(this,function(e){var y,g,d;"use strict";function r(n){var t=typeof n;return n&&(t==="object"||t==="function")}function f(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 l(n){return globalThis[n]}function m(n){let t=f(n);return s(t)}function a(n){return n==null||r(n)?f(n):typeof n}function b(n){var t=a(n);return s(t)}function A(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 O(n){return n&&typeof n[Symbol.iterator]=="function"}function p(n){return n&&typeof n.next=="function"}function u(n,...t){for(const i of t){const o=Object.getOwnPropertyDescriptors(i);Object.defineProperties(n,o)}return n}function E(n,t){return t}function h(){return function(t,i){return i}}function M(n,t){return u(n,t),t}function w(n){return function(i){return u(n,i),i}}function _(n,t){return u(n,t),n}function $(n){return function(i){return u(n,i),n}}function N(n,t){return t}function c(n,t){var o;u(n.prototype,t);const i=t._constructor;if(typeof i=="function"){const T=n;((o=T._constructors)!=null?o:T._constructors=[]).push(i)}return t}function S(n){return function(i){return c(n,i),i}}function j(n,t){return c(n,t),n}function v(n){return function(i){return c(n,i),n}}const I=/^[A-Za-z_$]+[\w$]*$/;function G(n){return I.test(n)}const x=/(^\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 z(n){const t=n.toString();return x.test(t)}const Z=(y=globalThis.AsyncFunction)!=null?y:async function(){}.constructor;function B(n){return n instanceof Z}const D=(g=globalThis.GeneratorFunction)!=null?g:function*(){}.constructor;function P(n){return n instanceof D}const L=(d=globalThis.AsyncGeneratorFunction)!=null?d:async function*(){}.constructor;function R(n){return n instanceof L}const k=/(^\s*(async\s+)?function\s*(\s|\*)\s*)[A-Za-z_$]+[\w$]*(\s*\()/;function q(n){if(n.name){const t=n.toString();return!k.test(t)}return!0}function C(n,t){return n instanceof Promise?n.then(i=>t(i,!1),i=>t(void 0,!0,i)):t(n,!1)}e.createDefineMixin=h,e.createExtendTarget=v,e.createMixinTarget=$,e.createTargetExtend=S,e.createTargetMixin=w,e.defineExtend=N,e.defineMixin=E,e.extendTarget=j,e.getExactTypeNameOf=b,e.getExactTypeOf=a,e.getNameOfType=s,e.getTypeByName=l,e.getTypeNameOf=m,e.getTypeOf=f,e.isAnonymousFunction=q,e.isArrayLike=F,e.isArrowFunction=z,e.isAsyncFunction=B,e.isAsyncGeneratorFunction=R,e.isBaseType=A,e.isGeneratorFunction=P,e.isIdentifier=G,e.isIterable=O,e.isIterator=p,e.isObject=r,e.mixin=u,e.mixinTarget=_,e.targetExtend=c,e.targetMixin=M,e.waitAsyncable=C,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});

package/doc/index.md

@@ -8,5 +8,5 @@
 
 |  Package | Description |
 |  --- | --- |
-|  [type-tls](./type-tls.md) | 处理类型相关的工具 |
+|  [type-tls](./type-tls.md) |  |
 

package/doc/type-tls.anyfunction.md

@@ -0,0 +1,13 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [type-tls](./type-tls.md) &gt; [AnyFunction](./type-tls.anyfunction.md)
+
+## AnyFunction type
+
+表示任意的函数类型
+
+<b>Signature:</b>
+
+```typescript
+export declare type AnyFunction = (...args: any) => any;
+```

package/doc/type-tls.classtype._new_.md

@@ -0,0 +1,22 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [type-tls](./type-tls.md) &gt; [ClassType](./type-tls.classtype.md) &gt; [(new)](./type-tls.classtype._new_.md)
+
+## ClassType.(new)
+
+<b>Signature:</b>
+
+```typescript
+new (...args: Arg): Instance;
+```
+
+## Parameters
+
+|  Parameter | Type | Description |
+|  --- | --- | --- |
+|  args | Arg |  |
+
+<b>Returns:</b>
+
+Instance
+

package/doc/type-tls.classtype.md

@@ -0,0 +1,20 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [type-tls](./type-tls.md) &gt; [ClassType](./type-tls.classtype.md)
+
+## ClassType interface
+
+类的类型、构造函数的类型
+
+<b>Signature:</b>
+
+```typescript
+export interface ClassType<Arg extends any[] = any[], Instance = any> 
+```
+
+## Methods
+
+|  Method | Description |
+|  --- | --- |
+|  [(new)(args)](./type-tls.classtype._new_.md) |  |
+

package/doc/type-tls.createdefinemixin.md

@@ -0,0 +1,23 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [type-tls](./type-tls.md) &gt; [createDefineMixin](./type-tls.createdefinemixin.md)
+
+## createDefineMixin() function
+
+创建定义混合的类型便利函数
+
+<b>Signature:</b>
+
+```typescript
+export declare function createDefineMixin<T>(): <M>(target: T, mixin: M & ThisType<T & M>) => M & ThisType<T & M>;
+```
+<b>Returns:</b>
+
+&lt;M&gt;(target: T, mixin: M &amp; ThisType&lt;T &amp; M&gt;) =&gt; M &amp; ThisType&lt;T &amp; M&gt;
+
+可以用于 定义混合的 类型便利函数
+
+## Remarks
+
+它返回的便利函数的功能与 [defineMixin()](./type-tls.definemixin.md) 的功能一样，唯一区别是不再需要接收 target 参数了
+

package/doc/type-tls.createextendtarget.md

@@ -0,0 +1,30 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [type-tls](./type-tls.md) &gt; [createExtendTarget](./type-tls.createextendtarget.md)
+
+## createExtendTarget() function
+
+创建用于扩展目标工具函数
+
+<b>Signature:</b>
+
+```typescript
+export declare function createExtendTarget<C extends ClassType>(cla: C): <E>(ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>) => ClassType<ConstructorParameters<C>, E & ThisType<InstanceType<C> & E>>;
+```
+
+## Parameters
+
+|  Parameter | Type | Description |
+|  --- | --- | --- |
+|  cla | C | 扩展的目标，也用作 this 的类型 |
+
+<b>Returns:</b>
+
+&lt;E&gt;(ext: E &amp; ThisType&lt;InstanceType&lt;C&gt; &amp; E&gt; &amp; [PrivateMemberOfExtend](./type-tls.privatememberofextend.md)<!-- -->&lt;C&gt;) =&gt; [ClassType](./type-tls.classtype.md)<!-- -->&lt;ConstructorParameters&lt;C&gt;, E &amp; ThisType&lt;InstanceType&lt;C&gt; &amp; E&gt;&gt;
+
+可以用于 扩展目标 的便利函数
+
+## Remarks
+
+它返回的便利函数的功能与 [extendTarget()](./type-tls.extendtarget.md) 的功能一样，唯一区别是不再需要接收 cla 参数了
+

package/doc/type-tls.createmixintarget.md

@@ -0,0 +1,30 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [type-tls](./type-tls.md) &gt; [createMixinTarget](./type-tls.createmixintarget.md)
+
+## createMixinTarget() function
+
+创建用于混合目标工具函数
+
+<b>Signature:</b>
+
+```typescript
+export declare function createMixinTarget<T>(target: T): <M>(m: M & ThisType<T & M>) => M & ThisType<T & M> & T;
+```
+
+## Parameters
+
+|  Parameter | Type | Description |
+|  --- | --- | --- |
+|  target | T |  |
+
+<b>Returns:</b>
+
+&lt;M&gt;(m: M &amp; ThisType&lt;T &amp; M&gt;) =&gt; M &amp; ThisType&lt;T &amp; M&gt; &amp; T
+
+可以用于 混合目标 的便利函数
+
+## Remarks
+
+它返回的便利函数的功能与 [mixinTarget()](./type-tls.mixintarget.md) 的功能一样，唯一区别是不再需要接收 target 参数了
+