type-tls 2.4.3 → 2.4.4

package/dist/type-tls.mjs

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

package/dist/type-tls.umd.js

@@ -1 +1 @@
-(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 v(n){return function(i){return u(n,i),n}}function $(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 N(n){return function(i){return c(n,i),i}}function S(n,t){return c(n,t),n}function j(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,void 0),i=>t(void 0,!0,i)):t(n,!1,void 0)}e.createDefineMixin=h,e.createExtendTarget=j,e.createMixinTarget=v,e.createTargetExtend=N,e.createTargetMixin=w,e.defineExtend=$,e.defineMixin=E,e.extendTarget=S,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"}})});
+(function(e,r){typeof exports=="object"&&typeof module<"u"?r(exports):typeof define=="function"&&define.amd?define(["exports"],r):(e=typeof globalThis<"u"?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 v(n){return function(i){return u(n,i),n}}function $(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 N(n){return function(i){return c(n,i),i}}function S(n,t){return c(n,t),n}function j(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,void 0),i=>t(void 0,!0,i)):t(n,!1,void 0)}e.createDefineMixin=h,e.createExtendTarget=j,e.createMixinTarget=v,e.createTargetExtend=N,e.createTargetMixin=w,e.defineExtend=$,e.defineMixin=E,e.extendTarget=S,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 → api/index.md}

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

package/doc/{type-tls.keyofvalue.md → api/type-tls.keyofvalue.md}

@@ -10,6 +10,6 @@
 
 ```typescript
 export declare type KeyOfValue<Target, Value> = {
-    [K in keyof Target]: Target[K] extends Value ? K : never;
+	[K in keyof Target]: Target[K] extends Value ? K : never;
 }[keyof Target];
 ```

package/doc/{type-tls.md → api/type-tls.md}

@@ -4,6 +4,12 @@
 
 ## type-tls package
 
+处理类型相关的工具
+
+## Remarks
+
+type-tls 封装了与类型相关的工具，比如获取数据的类型 或 类型名字、判断数据的类型 等
+
 ## Functions
 
 |  Function | Description |

package/doc/{type-tls.waitasyncablecallback.md → api/type-tls.waitasyncablecallback.md}

@@ -9,5 +9,7 @@ waitAsyncable 的回调函数的类型
 <b>Signature:</b>
 
 ```typescript
-export declare type WaitAsyncableCallback<Result, Return> = (result: Result | undefined, rejected: boolean, error: any) => Return;
+export declare type WaitAsyncableCallback<Result, Return> = (result: ResolveData<Result> | undefined, rejected: boolean, error: any) => Return;
 ```
+<b>References:</b> [ResolveData](./type-tls.resolvedata.md)
+

package/doc//346/225/231/347/250/213.md

@@ -0,0 +1,7 @@
+[API接口文档]: ./api/index.md
+
+> 由于时间关系，暂时还未编写教程，以后会抽空补齐。详情可查看[API接口文档][]。
+
+> 开源不易，还望多多支持！💖 💖 💖 
+
+![赞赏码](https://i.loli.net/2020/04/08/PGsAEqdJCin1oQL.jpg)

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "type-tls",
-  "version": "2.4.3",
+  "version": "2.4.4",
   "description": "type-tls 封装了与类型相关的工具，比如:获取数据的类型 或 类型名字、判断数据的类型 等",
   "main": "dist/type-tls.umd.js",
-  "module": "dist/type-tls.es.js",
+  "module": "dist/type-tls.mjs",
   "types": "dist/index.d.ts",
   "sideEffects": false,
   "homepage": "https://github.com/GuoBinyong/type-tls#readme",
@@ -33,14 +33,6 @@
     "docs/[^.]*",
     "doc/[^.]*"
   ],
-  "scripts": {
-    "dev": "vite",
-    "build": "vite build",
-    "bunch": "vite build --mode bunch",
-    "preview": "vite preview",
-    "api": "api-extractor run -c api-extractor.jsonc -l -v",
-    "doc": "npm run api ; api-documenter markdown -i ./temp -o doc"
-  },
   "devDependencies": {
     "@microsoft/api-documenter": "^7.17.15",
     "@microsoft/api-extractor": "^7.24.1",
@@ -48,6 +40,14 @@
     "dts-bundle-generator": "^6.12.0",
     "package-tls": "^1.3.1",
     "typescript": "^4.5.4",
-    "vite": "^2.9.9"
+    "vite": "^3.0.9"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "bunch": "vite build --mode bunch",
+    "preview": "vite preview",
+    "api": "api-extractor run -c api-extractor.jsonc -l -v",
+    "doc": "npm run api ; api-documenter markdown -i ./temp -o doc/api"
   }
-}
+}

package/dist/async.d.ts

@@ -1,28 +0,0 @@
-/**
- * 获取 Promise 解决的类型的值
- * @remarks
- * 对于非 Promise 类型的值，返回原类型本身
- */
-export declare type ResolveData<P> = P extends Promise<infer D> ? D : P;
-/**
- * waitAsyncable 的返回值的类型
- */
-export declare type WaitAsyncableReturn<Result, Return> = Return extends Promise<any> ? Return : (Result extends Promise<any> ? Promise<Return> : Return);
-/**
- * waitAsyncable 的回调函数的类型
- * @param result -  同步的结果
- * @param rejected - 异步是否被拒绝
- */
-export declare type WaitAsyncableCallback<Result, Return> = (result: Result | undefined, rejected: boolean, error: any) => Return;
-/**
- * 等待可异步的结果
- *
- * @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>;

package/dist/base.d.ts

@@ -1,190 +0,0 @@
-/**
- * 处理类型相关的工具
- * @remarks
- * type-tls 封装了与类型相关的工具，比如获取数据的类型 或 类型名字、判断数据的类型 等
- *
- * @packageDocumentation
- */
-/**
- * 判断目标是否是对象类型
- *
- * @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;
-/**
- * typeof 的返回类型
- */
-export declare type TypeOfReturnType = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-/**
- * 宽松的类型
- */
-export declare type LooseType = undefined | null | Function | "object";
-/**
- * 宽松类型的字符串表示
- */
-export declare type LooseTypeName = "undefined" | "null" | "Function" | "object" | string;
-/**
- * 精确类型
- *
- * @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">;
-/**
- * 获取 inst 的宽松类型
- *
- * @remarks
- * 注意：
- * 本方法返回的结果如下：
- * ```
- * undefined ：undefined
- * null ： null
- * function : Function
- * 没有原型的对象(如：通过 Object.create(null) 创建的对象) : "object"
- * 其它任何类型的实例  : 返回该实例的构造函数  或 包装对象的构造函数
- * ```
- *
- *
- * @param inst
- * @returns inst 的类型
- */
-export declare function getTypeOf(inst: any): LooseType;
-/**
- * 获取 类型的字符串表示
- *
- * @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 的精确类型
- * @param inst
- * @returns inst 的类型
- */
-export declare function getExactTypeOf(inst: any): ExactType;
-/**
- * 获取 inst 的精确类型的字符串表示
- * @param inst
- * @returns  inst 的类型字符串
- */
-export declare function getExactTypeNameOf(inst: any): ExactTypeName;
-/**
- * 判断 data 是否是 基本类型
- * @remarks
- * 基本类型 是指 那些不是 对象类型的类型，即，除了 object 和 function  类型以外，其它的都是基本类型，null 也算怎是 基本类型
- * @param data - 任意类型的值
- */
-export declare function isBaseType(data: any): boolean;
-/**
- * 判断 target 是否为 类数组对象
- * @param target  -  目标
- * @returns
- */
-export declare function isArrayLike(target: any): boolean;
-/**
- * 判断 目标 是否是可迭代的对象，即 实现了 可迭代协议
- * @param target - 目标
- */
-export declare function isIterable(target: any): boolean;
-/**
- * 判断 目标 是否是迭代器，即 实现了 迭代器协议
- * @param target - 目标
- */
-export declare function isIterator(target: any): boolean;
-/**
- * 将某个类型变为可选的类型
- */
-export declare type Optional<T> = T | null | undefined;
-/**
- * 可选的布尔类型
- */
-export declare type OptionalBoolean = Optional<boolean>;
-/**
- * 获取值类型为指定类型的所有 key
- */
-export declare type KeyOfValue<Target, Value> = {
-    [K in keyof Target]: Target[K] extends Value ? K : never;
-}[keyof Target];
-/**
- * 可将源类型 SourType 中的 类型 MatchType 替换为 新的类型 NewType
- */
-export declare type Replace<SourType, MatchType, NewType> = SourType extends MatchType ? NewType : SourType;
-/**
- * 可将源类型 SourType 中的 undefined 替换为 新的类型 NewType
- */
-export declare type ReplaceUndefined<SourType, NewType> = Replace<SourType, undefined, NewType>;
-/**
- * 可将源类型 SourType 中的 null 替换为 新的类型 NewType
- */
-export declare type ReplaceNull<SourType, NewType> = Replace<SourType, null, NewType>;
-/**
- * 可将源类型 SourType 中的代表空的类型 void | undefined | null 替换为 新的类型 NewType
- */
-export declare type ReplaceVoid<SourType, NewType> = Replace<SourType, void | undefined | null, NewType>;

package/dist/buffer.d.ts

@@ -1 +0,0 @@
-export declare type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array | Float32Array | Float64Array;