lakutata 0.0.1

package/build/chunk-XO6M5AYN.js

@@ -0,0 +1,585 @@
+import { require_is_glob } from './chunk-J6RXNX2K.js';
+import { OBJECT_INIT_MARK } from './chunk-4OHSPWRQ.js';
+import { __commonJS, init_esm_shims, __require, __name, __toESM } from './chunk-5NK7E2HA.js';
+import { setTimeout } from 'timers/promises';
+import { isPromise as isPromise$1 } from 'util/types';
+import { Stream } from 'stream';
+
+// node_modules/randombytes/index.js
+var require_randombytes = __commonJS({
+  "node_modules/randombytes/index.js"(exports, module) {
+    init_esm_shims();
+    module.exports = __require("crypto").randomBytes;
+  }
+});
+
+// node_modules/randomstring/lib/charset.js
+var require_charset = __commonJS({
+  "node_modules/randomstring/lib/charset.js"(exports, module) {
+    init_esm_shims();
+    function Charset() {
+      this.chars = "";
+    }
+    __name(Charset, "Charset");
+    Charset.prototype.setType = function(type) {
+      if (Array.isArray(type)) {
+        for (var i = 0; i < type.length; i++) {
+          this.chars += this.getCharacters(type[i]);
+        }
+      } else {
+        this.chars = this.getCharacters(type);
+      }
+    };
+    Charset.prototype.getCharacters = function(type) {
+      var chars;
+      var numbers = "0123456789";
+      var charsLower = "abcdefghijklmnopqrstuvwxyz";
+      var charsUpper = charsLower.toUpperCase();
+      var hexChars = "abcdef";
+      var binaryChars = "01";
+      var octalChars = "01234567";
+      if (type === "alphanumeric") {
+        chars = numbers + charsLower + charsUpper;
+      } else if (type === "numeric") {
+        chars = numbers;
+      } else if (type === "alphabetic") {
+        chars = charsLower + charsUpper;
+      } else if (type === "hex") {
+        chars = numbers + hexChars;
+      } else if (type === "binary") {
+        chars = binaryChars;
+      } else if (type === "octal") {
+        chars = octalChars;
+      } else {
+        chars = type;
+      }
+      return chars;
+    };
+    Charset.prototype.removeUnreadable = function() {
+      var unreadableChars = /[0OIl]/g;
+      this.chars = this.chars.replace(unreadableChars, "");
+    };
+    Charset.prototype.setcapitalization = function(capitalization) {
+      if (capitalization === "uppercase") {
+        this.chars = this.chars.toUpperCase();
+      } else if (capitalization === "lowercase") {
+        this.chars = this.chars.toLowerCase();
+      }
+    };
+    Charset.prototype.removeDuplicates = function() {
+      var charMap = this.chars.split("");
+      charMap = [...new Set(charMap)];
+      this.chars = charMap.join("");
+    };
+    module.exports = Charset;
+  }
+});
+
+// node_modules/randomstring/lib/randomstring.js
+var require_randomstring = __commonJS({
+  "node_modules/randomstring/lib/randomstring.js"(exports) {
+    init_esm_shims();
+    var randomBytes = require_randombytes();
+    var Charset = require_charset();
+    function unsafeRandomBytes(length) {
+      var stack = [];
+      for (var i = 0; i < length; i++) {
+        stack.push(Math.floor(Math.random() * 255));
+      }
+      return {
+        length,
+        readUInt8: function(index) {
+          return stack[index];
+        }
+      };
+    }
+    __name(unsafeRandomBytes, "unsafeRandomBytes");
+    function safeRandomBytes(length) {
+      try {
+        return randomBytes(length);
+      } catch (e) {
+        return unsafeRandomBytes(length);
+      }
+    }
+    __name(safeRandomBytes, "safeRandomBytes");
+    function processString(buf, initialString, chars, reqLen, maxByte) {
+      var string = initialString;
+      for (var i = 0; i < buf.length && string.length < reqLen; i++) {
+        var randomByte = buf.readUInt8(i);
+        if (randomByte < maxByte) {
+          string += chars.charAt(randomByte % chars.length);
+        }
+      }
+      return string;
+    }
+    __name(processString, "processString");
+    function getAsyncString(string, chars, length, maxByte, cb) {
+      randomBytes(length, function(err, buf) {
+        if (err) {
+          cb(err);
+        }
+        var generatedString = processString(buf, string, chars, length, maxByte);
+        if (generatedString.length < length) {
+          getAsyncString(generatedString, chars, length, maxByte, cb);
+        } else {
+          cb(null, generatedString);
+        }
+      });
+    }
+    __name(getAsyncString, "getAsyncString");
+    exports.generate = function(options, cb) {
+      var charset = new Charset();
+      var length, string = "";
+      if (typeof options === "object") {
+        length = typeof options.length === "number" ? options.length : 32;
+        if (options.charset) {
+          charset.setType(options.charset);
+        } else {
+          charset.setType("alphanumeric");
+        }
+        if (options.capitalization) {
+          charset.setcapitalization(options.capitalization);
+        }
+        if (options.readable) {
+          charset.removeUnreadable();
+        }
+        charset.removeDuplicates();
+      } else if (typeof options === "number") {
+        length = options;
+        charset.setType("alphanumeric");
+      } else {
+        length = 32;
+        charset.setType("alphanumeric");
+      }
+      var charsLen = charset.chars.length;
+      var maxByte = 256 - 256 % charsLen;
+      if (!cb) {
+        while (string.length < length) {
+          var buf = safeRandomBytes(Math.ceil(length * 256 / maxByte));
+          string = processString(buf, string, charset.chars, length, maxByte);
+        }
+        return string;
+      }
+      getAsyncString(string, charset.chars, length, maxByte, cb);
+    };
+  }
+});
+
+// node_modules/randomstring/index.js
+var require_randomstring2 = __commonJS({
+  "node_modules/randomstring/index.js"(exports, module) {
+    init_esm_shims();
+    module.exports = require_randomstring();
+  }
+});
+
+// src/Utilities.ts
+init_esm_shims();
+
+// node_modules/sort-array/index.mjs
+init_esm_shims();
+
+// node_modules/array-back/index.mjs
+init_esm_shims();
+function isObject(input) {
+  return typeof input === "object" && input !== null;
+}
+__name(isObject, "isObject");
+function isArrayLike(input) {
+  return isObject(input) && typeof input.length === "number";
+}
+__name(isArrayLike, "isArrayLike");
+function arrayify(input) {
+  if (Array.isArray(input)) {
+    return input;
+  } else if (input === void 0) {
+    return [];
+  } else if (isArrayLike(input) || input instanceof Set) {
+    return Array.from(input);
+  } else {
+    return [input];
+  }
+}
+__name(arrayify, "arrayify");
+var array_back_default = arrayify;
+
+// node_modules/typical/index.mjs
+init_esm_shims();
+function isNumber(n) {
+  return !isNaN(parseFloat(n)) && isFinite(n);
+}
+__name(isNumber, "isNumber");
+function isPlainObject(input) {
+  return input !== null && typeof input === "object" && input.constructor === Object;
+}
+__name(isPlainObject, "isPlainObject");
+function isArrayLike2(input) {
+  return isObject2(input) && typeof input.length === "number";
+}
+__name(isArrayLike2, "isArrayLike");
+function isObject2(input) {
+  return typeof input === "object" && input !== null;
+}
+__name(isObject2, "isObject");
+function isDefined(input) {
+  return typeof input !== "undefined";
+}
+__name(isDefined, "isDefined");
+function isUndefined(input) {
+  return !isDefined(input);
+}
+__name(isUndefined, "isUndefined");
+function isNull(input) {
+  return input === null;
+}
+__name(isNull, "isNull");
+function isDefinedValue(input) {
+  return isDefined(input) && !isNull(input) && !Number.isNaN(input);
+}
+__name(isDefinedValue, "isDefinedValue");
+function isClass(input) {
+  if (typeof input === "function") {
+    return /^class /.test(Function.prototype.toString.call(input));
+  } else {
+    return false;
+  }
+}
+__name(isClass, "isClass");
+function isPrimitive(input) {
+  if (input === null)
+    return true;
+  switch (typeof input) {
+    case "string":
+    case "number":
+    case "symbol":
+    case "undefined":
+    case "boolean":
+      return true;
+    default:
+      return false;
+  }
+}
+__name(isPrimitive, "isPrimitive");
+function isPromise(input) {
+  if (input) {
+    const isPromise3 = isDefined(Promise) && input instanceof Promise;
+    const isThenable = input.then && typeof input.then === "function";
+    return !!(isPromise3 || isThenable);
+  } else {
+    return false;
+  }
+}
+__name(isPromise, "isPromise");
+function isIterable(input) {
+  if (input === null || !isDefined(input)) {
+    return false;
+  } else {
+    return typeof input[Symbol.iterator] === "function" || typeof input[Symbol.asyncIterator] === "function";
+  }
+}
+__name(isIterable, "isIterable");
+function isString(input) {
+  return typeof input === "string";
+}
+__name(isString, "isString");
+function isFunction(input) {
+  return typeof input === "function";
+}
+__name(isFunction, "isFunction");
+var typical_default = {
+  isNumber,
+  isPlainObject,
+  isArrayLike: isArrayLike2,
+  isObject: isObject2,
+  isDefined,
+  isUndefined,
+  isNull,
+  isDefinedValue,
+  isClass,
+  isPrimitive,
+  isPromise,
+  isIterable,
+  isString,
+  isFunction
+};
+
+// node_modules/sort-array/index.mjs
+function sortArray(arr, options = {}) {
+  options = Object.assign(
+    {
+      computed: {},
+      customOrders: {},
+      nullRank: 1,
+      undefinedRank: 1
+    },
+    options
+  );
+  arr.sort(getCompareFunc(options));
+  return arr;
+}
+__name(sortArray, "sortArray");
+function getCompareFunc(options = {}) {
+  const by = array_back_default(options.by);
+  const order = array_back_default(options.order);
+  const { customOrders, computed } = options;
+  return /* @__PURE__ */ __name(function compareFunc(xIn, yIn, byIndex = 0) {
+    const currOrder = order[byIndex] || "asc";
+    if (!(currOrder === "asc" || currOrder === "desc" || customOrders[currOrder])) {
+      return 0;
+    }
+    let result, x, y;
+    if (by.length) {
+      x = typical_default.isDefined(xIn[by[byIndex]]) ? xIn[by[byIndex]] : computed[by[byIndex]] && computed[by[byIndex]](xIn);
+      y = typical_default.isDefined(yIn[by[byIndex]]) ? yIn[by[byIndex]] : computed[by[byIndex]] && computed[by[byIndex]](yIn);
+    } else {
+      x = xIn;
+      y = yIn;
+    }
+    if (customOrders && customOrders[currOrder]) {
+      result = customOrders[currOrder].indexOf(x) - customOrders[currOrder].indexOf(y);
+    } else if (x === y) {
+      result = 0;
+    } else if (typical_default.isNull(x) && typical_default.isUndefined(y)) {
+      result = currOrder === "asc" ? 1 : currOrder === "desc" ? -1 : 0;
+    } else if (typical_default.isUndefined(x) && typical_default.isNull(y)) {
+      result = currOrder === "asc" ? -1 : currOrder === "desc" ? 1 : 0;
+    } else if (typical_default.isNull(x) && typical_default.isDefinedValue(y)) {
+      result = options.nullRank;
+    } else if (typical_default.isUndefined(x) && typical_default.isDefinedValue(y)) {
+      result = options.undefinedRank;
+    } else if (typical_default.isNull(y) && typical_default.isDefinedValue(x)) {
+      result = -options.nullRank;
+    } else if (typical_default.isUndefined(y) && typical_default.isDefinedValue(x)) {
+      result = -options.undefinedRank;
+    } else {
+      result = x < y ? -1 : x > y ? 1 : 0;
+      if (currOrder === "desc") {
+        result = result * -1;
+      }
+    }
+    if (result === 0 && typical_default.isDefined(by[byIndex + 1])) {
+      result = compareFunc(xIn, yIn, byIndex + 1);
+    }
+    return result;
+  }, "compareFunc");
+}
+__name(getCompareFunc, "getCompareFunc");
+var sort_array_default = sortArray;
+
+// node_modules/sort-keys/index.js
+init_esm_shims();
+
+// node_modules/is-plain-obj/index.js
+init_esm_shims();
+function isPlainObject2(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+__name(isPlainObject2, "isPlainObject");
+
+// node_modules/sort-keys/index.js
+function sortKeys(object, options = {}) {
+  if (!isPlainObject2(object) && !Array.isArray(object)) {
+    throw new TypeError("Expected a plain object or array");
+  }
+  const { deep, compare } = options;
+  const seenInput = [];
+  const seenOutput = [];
+  const deepSortArray = /* @__PURE__ */ __name((array) => {
+    const seenIndex = seenInput.indexOf(array);
+    if (seenIndex !== -1) {
+      return seenOutput[seenIndex];
+    }
+    const result = [];
+    seenInput.push(array);
+    seenOutput.push(result);
+    result.push(...array.map((item) => {
+      if (Array.isArray(item)) {
+        return deepSortArray(item);
+      }
+      if (isPlainObject2(item)) {
+        return _sortKeys(item);
+      }
+      return item;
+    }));
+    return result;
+  }, "deepSortArray");
+  const _sortKeys = /* @__PURE__ */ __name((object2) => {
+    const seenIndex = seenInput.indexOf(object2);
+    if (seenIndex !== -1) {
+      return seenOutput[seenIndex];
+    }
+    const result = {};
+    const keys = Object.keys(object2).sort(compare);
+    seenInput.push(object2);
+    seenOutput.push(result);
+    for (const key of keys) {
+      const value = object2[key];
+      let newValue;
+      if (deep && Array.isArray(value)) {
+        newValue = deepSortArray(value);
+      } else {
+        newValue = deep && isPlainObject2(value) ? _sortKeys(value) : value;
+      }
+      Object.defineProperty(result, key, {
+        ...Object.getOwnPropertyDescriptor(object2, key),
+        value: newValue
+      });
+    }
+    return result;
+  }, "_sortKeys");
+  if (Array.isArray(object)) {
+    return deep ? deepSortArray(object) : object.slice();
+  }
+  return _sortKeys(object);
+}
+__name(sortKeys, "sortKeys");
+
+// src/Utilities.ts
+var import_is_glob = __toESM(require_is_glob(), 1);
+var randomString = __toESM(require_randomstring2(), 1);
+function IsEqual(val1, val2) {
+  const compareSet = /* @__PURE__ */ new Set();
+  compareSet.add(val1).add(val2);
+  return compareSet.size === 2;
+}
+__name(IsEqual, "IsEqual");
+function IsPath(inp) {
+  try {
+    const pathRegex = new RegExp('^(\\/|\\.\\.?\\/|([A-Za-z]:)?\\\\)([^\\\\\\/:*?"<>|\\r\\n]+[\\\\\\/])*[^\\\\\\/:*?"<>|\\r\\n]*$');
+    return pathRegex.test(As(inp));
+  } catch (e) {
+    return false;
+  }
+}
+__name(IsPath, "IsPath");
+function* ConvertToIterable(inp) {
+  for (let i = 0; i < inp.length; i++)
+    yield inp[i];
+}
+__name(ConvertToIterable, "ConvertToIterable");
+function ConvertToStream(inp, options) {
+  options = options ? options : {};
+  return Stream.Readable.from(ConvertToIterable(inp), options);
+}
+__name(ConvertToStream, "ConvertToStream");
+function isPromise2(target) {
+  return isPromise$1(target) ? true : !!target && (typeof target === "object" || typeof target === "function") && typeof target.then === "function";
+}
+__name(isPromise2, "isPromise");
+async function Delay(ms = 1e3) {
+  return await setTimeout(ms);
+}
+__name(Delay, "Delay");
+function ThrowIntoBlackHole(...args) {
+}
+__name(ThrowIntoBlackHole, "ThrowIntoBlackHole");
+function IsObjectInitialized(obj) {
+  return !!Reflect.getOwnMetadata(OBJECT_INIT_MARK, obj);
+}
+__name(IsObjectInitialized, "IsObjectInitialized");
+function MergeSet(s1, s2) {
+  return /* @__PURE__ */ new Set([...s1, ...s2]);
+}
+__name(MergeSet, "MergeSet");
+function MergeArray(arr1, arr2) {
+  return [...arr1, ...arr2];
+}
+__name(MergeArray, "MergeArray");
+function MergeMap(m1, m2) {
+  return new Map([...m1, ...m2]);
+}
+__name(MergeMap, "MergeMap");
+function SetToArray(set) {
+  return Array.from(set);
+}
+__name(SetToArray, "SetToArray");
+function ArrayToSet(arr) {
+  return new Set(arr);
+}
+__name(ArrayToSet, "ArrayToSet");
+function UniqueArray(arr) {
+  return Array.from(new Set(arr));
+}
+__name(UniqueArray, "UniqueArray");
+function SortArray(arr, ...options) {
+  if (options.length < 2) {
+    let sortOptions = { order: "asc" };
+    if (options.length)
+      sortOptions = Object.assign(sortOptions, {
+        by: options[0].by,
+        order: options[0].order,
+        computed: options[0].computed
+      });
+    return sort_array_default(arr, sortOptions);
+  } else {
+    const sortsOptions = {
+      by: [],
+      order: [],
+      customOrders: {}
+    };
+    options.forEach((opt) => {
+      if (opt.by) {
+        const field = opt.by;
+        sortsOptions.by.push(field);
+        sortsOptions.order.push(field);
+        sortsOptions.customOrders[field] = SortArray(arr, opt).map((value) => value[field]);
+      }
+    });
+    return sort_array_default(arr, sortsOptions);
+  }
+}
+__name(SortArray, "SortArray");
+function SortObject(object, options) {
+  return sortKeys(object, {
+    deep: options == null ? void 0 : options.deep,
+    compare: (a, b) => {
+      switch (options == null ? void 0 : options.order) {
+        case "asc":
+          return a.localeCompare(b);
+        case "desc":
+          return -a.localeCompare(b);
+        default:
+          return a.localeCompare(b);
+      }
+    }
+  });
+}
+__name(SortObject, "SortObject");
+function ConfigureObjectProperties(target, properties) {
+  Object.keys(properties ? properties : {}).forEach((propertyKey) => target[propertyKey] = properties[propertyKey]);
+}
+__name(ConfigureObjectProperties, "ConfigureObjectProperties");
+function As(inp) {
+  return inp;
+}
+__name(As, "As");
+function IsGlobString(inp) {
+  return (0, import_is_glob.default)(inp);
+}
+__name(IsGlobString, "IsGlobString");
+function RandomString(length, charset) {
+  return randomString.generate({
+    length: length !== void 0 ? length : 32,
+    charset: As(charset !== void 0 ? charset : "alphanumeric")
+  });
+}
+__name(RandomString, "RandomString");
+function NonceStr() {
+  return RandomString(32, "alphanumeric");
+}
+__name(NonceStr, "NonceStr");
+function ParentConstructor(target) {
+  const rootProto = Symbol.constructor.prototype.constructor.__proto__;
+  const constructor = !!target[Symbol.hasInstance] && target.prototype ? target : target.constructor;
+  const proto = constructor.prototype.constructor.__proto__;
+  return proto === rootProto ? null : proto;
+}
+__name(ParentConstructor, "ParentConstructor");
+
+export { ArrayToSet, As, ConfigureObjectProperties, ConvertToIterable, ConvertToStream, Delay, IsEqual, IsGlobString, IsObjectInitialized, IsPath, MergeArray, MergeMap, MergeSet, NonceStr, ParentConstructor, RandomString, SetToArray, SortArray, SortObject, ThrowIntoBlackHole, UniqueArray, isPromise2 as isPromise };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../node_modules/randombytes/index.js","../node_modules/randomstring/lib/charset.js","../node_modules/randomstring/lib/randomstring.js","../node_modules/randomstring/index.js","../src/Utilities.ts","../node_modules/sort-array/index.mjs","../node_modules/array-back/index.mjs","../node_modules/typical/index.mjs","../node_modules/sort-keys/index.js","../node_modules/is-plain-obj/index.js"],"names":["require_randomstring","isArrayLike","isObject","isPromise","isPlainObject","object","isGlob"],"mappings":"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","sourcesContent":["module.exports = require('crypto').randomBytes\n","function Charset() {\n  this.chars = '';\n}\n\nCharset.prototype.setType = function(type) {\n  if (Array.isArray(type)) {\n    for (var i=0; i < type.length; i++) {\n      this.chars += this.getCharacters(type[i]);\n    }\n  }\n  else {\n    this.chars = this.getCharacters(type);\n  }\n}\n\nCharset.prototype.getCharacters = function(type) {\n  var chars;\n\n  var numbers     = '0123456789';\n  var charsLower  = 'abcdefghijklmnopqrstuvwxyz';\n  var charsUpper  = charsLower.toUpperCase();\n  var hexChars    = 'abcdef';\n  var binaryChars = '01';\n  var octalChars  = '01234567';\n\n  if (type === 'alphanumeric') {\n    chars = numbers + charsLower + charsUpper;\n  }\n  else if (type === 'numeric') {\n    chars = numbers;\n  }\n  else if (type === 'alphabetic') {\n    chars = charsLower + charsUpper;\n  }\n  else if (type === 'hex') {\n    chars = numbers + hexChars;\n  }\n  else if (type === 'binary') {\n    chars = binaryChars;\n  }\n  else if (type === 'octal') {\n    chars = octalChars;\n  }\n  else {\n    chars = type;\n  }\n\n  return chars;\n}\n\nCharset.prototype.removeUnreadable = function() {\n  var unreadableChars = /[0OIl]/g;\n  this.chars = this.chars.replace(unreadableChars, '');\n}\n\nCharset.prototype.setcapitalization = function(capitalization) {\n  if (capitalization === 'uppercase') {\n    this.chars = this.chars.toUpperCase();\n  }\n  else if (capitalization === 'lowercase') {\n    this.chars = this.chars.toLowerCase();\n  }\n}\n\nCharset.prototype.removeDuplicates = function() {\n  var charMap = this.chars.split('');\n  charMap = [...new Set(charMap)];\n  this.chars = charMap.join('');\n}\n\nmodule.exports = exports = Charset;\n","\"use strict\";\n\nvar randomBytes = require('randombytes');\nvar Charset = require('./charset.js');\n\n\nfunction unsafeRandomBytes(length) {\n  var stack = [];\n  for (var i = 0; i < length; i++) {\n    stack.push(Math.floor(Math.random() * 255));\n  }\n\n  return {\n    length,\n    readUInt8: function (index) {\n      return stack[index];\n    }\n  };\n}\n\nfunction safeRandomBytes(length) {\n  try {\n    return randomBytes(length);\n  } catch (e) {\n    /* React/React Native Fix + Eternal loop removed */\n    return unsafeRandomBytes(length);\n  }\n}\n\nfunction processString(buf, initialString, chars, reqLen, maxByte) {\n  var string = initialString;\n  for (var i = 0; i < buf.length && string.length < reqLen; i++) {\n    var randomByte = buf.readUInt8(i);\n    if (randomByte < maxByte) {\n      string += chars.charAt(randomByte % chars.length);\n    }\n  }\n  return string;\n}\n\nfunction getAsyncString(string, chars, length, maxByte, cb) {\n  randomBytes(length, function(err, buf) {\n    if (err) {\n      // Since it is waiting for entropy, errors are legit and we shouldn't just keep retrying\n      cb(err);\n    }\n    var generatedString = processString(buf, string, chars, length, maxByte);\n    if (generatedString.length < length) {\n      getAsyncString(generatedString, chars, length, maxByte, cb);\n    } else {\n      cb(null, generatedString);\n    }\n  })\n}\n\nexports.generate = function(options, cb) {\n  var charset = new Charset();\n\n  var length, chars, capitalization, string = '';\n\n  // Handle options\n  if (typeof options === 'object') {\n    length = typeof options.length === 'number' ? options.length : 32;\n\n    if (options.charset) {\n      charset.setType(options.charset);\n    }\n    else {\n      charset.setType('alphanumeric');\n    }\n\n    if (options.capitalization) {\n      charset.setcapitalization(options.capitalization);\n    }\n\n    if (options.readable) {\n      charset.removeUnreadable();\n    }\n\n    charset.removeDuplicates();\n  }\n  else if (typeof options === 'number') {\n    length = options;\n    charset.setType('alphanumeric');\n  }\n  else {\n    length = 32;\n    charset.setType('alphanumeric');\n  }\n\n  // Generate the string\n  var charsLen = charset.chars.length;\n  var maxByte = 256 - (256 % charsLen);\n\n  if (!cb) {\n    while (string.length < length) {\n      var buf = safeRandomBytes(Math.ceil(length * 256 / maxByte));\n      string = processString(buf, string, charset.chars, length, maxByte);\n    }\n\n    return string;\n  }\n\n  getAsyncString(string, charset.chars, length, maxByte, cb);\n\n};\n","module.exports = require(\"./lib/randomstring\");","import 'reflect-metadata'\nimport sortArray from 'sort-array'\nimport {ISortArrayOptions} from './interfaces/ISortArrayOptions.js'\nimport sortKeys from 'sort-keys'\nimport {ISortObjectOptions} from './interfaces/ISortObjectOptions.js'\nimport isGlob from 'is-glob'\nimport * as randomString from 'randomstring'\nimport {IConstructor} from './interfaces/IConstructor.js'\nimport {BaseObject} from './lib/base/BaseObject.js'\nimport {OBJECT_INIT_MARK} from './constants/MetadataKey.js'\nimport {setTimeout} from 'timers/promises'\nimport {isPromise as isBuiltinPromises} from 'util/types'\nimport {Readable as ReadableStream, ReadableOptions, Stream} from 'stream'\nimport {PathLike} from 'fs'\n\n/**\n * 判断两个传入的值是否相等\n * @param val1\n * @param val2\n * @constructor\n */\nexport function IsEqual(val1: any, val2: any): boolean {\n    const compareSet: Set<any> = new Set()\n    compareSet.add(val1).add(val2)\n    return compareSet.size === 2\n}\n\n/**\n * 判断输入的内容是否为路径\n * @param inp\n * @constructor\n */\nexport function IsPath(inp: string | PathLike): boolean {\n    try {\n        const pathRegex: RegExp = new RegExp('^(\\\\/|\\\\.\\\\.?\\\\/|([A-Za-z]:)?\\\\\\\\)([^\\\\\\\\\\\\/:*?\"<>|\\\\r\\\\n]+[\\\\\\\\\\\\/])*[^\\\\\\\\\\\\/:*?\"<>|\\\\r\\\\n]*$')\n        return pathRegex.test(As<string>(inp))\n    } catch (e) {\n        return false\n    }\n}\n\n/**\n * 将输入对象转换为生成器对象\n * @param inp\n * @constructor\n */\nexport function* ConvertToIterable(inp: string | Buffer | NodeJS.TypedArray): Generator {\n    for (let i = 0; i < inp.length; i++) yield inp[i]\n}\n\n/**\n * 转换Buffer为可读流\n * @param inp\n * @param options\n * @constructor\n */\nexport function ConvertToStream(inp: Buffer, options?: ReadableOptions): ReadableStream\n/**\n * 转换TypedArray为可读流\n * @param inp\n * @param options\n * @constructor\n */\nexport function ConvertToStream(inp: NodeJS.TypedArray, options?: ReadableOptions): ReadableStream\n/**\n * 转换字符串为可读流\n * @param inp\n * @param options\n * @constructor\n */\nexport function ConvertToStream(inp: string, options?: ReadableOptions): ReadableStream\nexport function ConvertToStream(inp: any, options?: ReadableOptions): ReadableStream {\n    options = options ? options : {}\n    return Stream.Readable.from(ConvertToIterable(inp), options)\n}\n\n/**\n * 判断一个目标对象是否为Promise\n * @param obj\n */\nexport function isPromise(target: any): boolean {\n    return isBuiltinPromises(target) ? true : !!target && (typeof target === 'object' || typeof target === 'function') && typeof target.then === 'function'\n}\n\n/**\n * 异步等待\n * @param ms\n * @constructor\n */\nexport async function Delay(ms: number = 1000): Promise<void> {\n    return await setTimeout(ms)\n}\n\n/**\n * 传递进来的参数不会有任何作用\n * @constructor\n */\nexport function ThrowIntoBlackHole(...args: any[]): void {\n    /**\n     * 仅接受参数，但不对参数做任何处理\n     */\n}\n\n/**\n * 对象是否已被初始化\n * @param obj\n * @constructor\n */\nexport function IsObjectInitialized<T extends BaseObject>(obj: T): boolean {\n    return !!Reflect.getOwnMetadata(OBJECT_INIT_MARK, obj)\n}\n\n/**\n * 合并两个Set\n * @constructor\n * @param s1\n * @param s2\n */\nexport function MergeSet<T = any, U = any>(s1: Set<T>, s2: Set<U>): Set<T | U> {\n    return new Set<T | U>([...s1, ...s2])\n}\n\n/**\n * 合并两个数组\n * @param arr1\n * @param arr2\n * @constructor\n */\nexport function MergeArray<T = any, U = any>(arr1: T[], arr2: U[]): (T | U)[] {\n    return [...arr1, ...arr2]\n}\n\n/**\n * 合并两个Map\n * @constructor\n * @param m1\n * @param m2\n */\nexport function MergeMap<K1, V1, K2, V2>(m1: Map<K1, V1>, m2: Map<K2, V2>): Map<K1 | K2, V1 | V2> {\n    return new Map<K1 | K2, V1 | V2>([...m1, ...m2])\n}\n\n/**\n * 集合转数组\n * @param set\n * @constructor\n */\nexport function SetToArray<T = any>(set: Set<T>): T[] {\n    return Array.from(set)\n}\n\n/**\n * 数组转集合\n * @param arr\n * @constructor\n */\nexport function ArrayToSet<T = any>(arr: T[]): Set<T> {\n    return new Set(arr)\n}\n\n/**\n * 数组去重\n * @param arr\n * @constructor\n */\nexport function UniqueArray<T>(arr: T[]): T[] {\n    return Array.from(new Set(arr))\n}\n\n/**\n * 数组排序\n * @param arr\n * @param options\n * @constructor\n */\nexport function SortArray<T = any>(arr: T[], ...options: ISortArrayOptions<T>[]): T[] {\n    if (options.length < 2) {\n        let sortOptions: { [key: string]: any } = {order: 'asc'}\n        if (options.length) sortOptions = Object.assign(sortOptions, {\n            by: options[0].by,\n            order: options[0].order,\n            computed: options[0].computed\n        })\n        return sortArray(arr, sortOptions)\n    } else {\n        const sortsOptions: { [key: string]: any } = {\n            by: [],\n            order: [],\n            customOrders: {}\n        }\n        options.forEach((opt: ISortArrayOptions<T>): void => {\n            if (opt.by) {\n                const field: string = opt.by as any\n                sortsOptions.by.push(field)\n                sortsOptions.order.push(field)\n                sortsOptions.customOrders[field] = SortArray(arr, opt).map(value => value[field])\n            }\n        })\n        return sortArray(arr, sortsOptions)\n    }\n}\n\n/**\n * 对象排序\n * @param object\n * @param options\n * @constructor\n */\nexport function SortObject<T extends Record<string, any>>(object: T, options?: ISortObjectOptions): T {\n    return sortKeys(object, {\n        deep: options?.deep, compare: (a: string, b: string): number => {\n            switch (options?.order) {\n                case 'asc':\n                    return a.localeCompare(b)\n                case 'desc':\n                    return -a.localeCompare(b)\n                default:\n                    return a.localeCompare(b)\n            }\n        }\n    })\n}\n\n/**\n * 配置对象属性\n * @param target\n * @param properties\n * @constructor\n */\nexport function ConfigureObjectProperties<T extends object = object>(target: T, properties: Record<string, any>): void {\n    Object.keys(properties ? properties : {}).forEach((propertyKey: string) => target[propertyKey] = properties![propertyKey])\n}\n\n/**\n * 类型转换\n * @param inp\n * @constructor\n */\nexport function As<T = any>(inp: any): T {\n    return inp as T\n}\n\n/**\n * 判断是否为通配符匹配操作符字符串\n * @param inp\n */\nexport function IsGlobString(inp: string): boolean {\n    return isGlob(inp)\n}\n\n/**\n * 生成随机字符串\n */\nexport function RandomString(): string\n/**\n * 生成指定长度的随机字符串\n * @param length\n */\nexport function RandomString(length: number): string\n/**\n * 生成仅包含字符集内字符的指定长度字符串\n * @param length\n * @param charset\n */\nexport function RandomString(length: number, charset: string): string\n/**\n * 生成仅包含[0-9 a-z A-Z]的指定长度字符串\n * @param length\n * @param charset\n */\nexport function RandomString(length: number, charset: 'alphanumeric'): string\n/**\n * 生成仅包含[a-z A-Z]的指定长度字符串\n * @param length\n * @param charset\n */\nexport function RandomString(length: number, charset: 'alphabetic'): string\n/**\n * 生成仅包含[0-9]的指定长度字符串\n * @param length\n * @param charset\n */\nexport function RandomString(length: number, charset: 'numeric'): string\n/**\n * 生成仅包含[0-9 a-f]的指定长度字符串\n * @param length\n * @param charset\n */\nexport function RandomString(length: number, charset: 'hex'): string\n/**\n * 生成仅包含[01]的指定长度字符串\n * @param length\n * @param charset\n */\nexport function RandomString(length: number, charset: 'binary'): string\n/**\n * 生成仅包含[0-7]的指定长度字符串\n * @param length\n * @param charset\n */\nexport function RandomString(length: number, charset: 'octal'): string\n/**\n * 生成仅包含字符集数组内字符规则的指定长度字符串\n * @param length\n * @param charset\n */\nexport function RandomString(length: number, charset: ('alphanumeric' | 'alphabetic' | 'numeric' | 'hex' | 'binary' | 'octal' | string)[]): string\nexport function RandomString(length?: number, charset?: string | string[]): string {\n    return randomString.generate({\n        length: length !== undefined ? length : 32,\n        charset: As<string>(charset !== undefined ? charset : 'alphanumeric')\n    })\n}\n\n/**\n * 生成32位的随机字符串\n * @constructor\n */\nexport function NonceStr(): string {\n    return RandomString(32, 'alphanumeric')\n}\n\n/**\n * 获取类实例/构造函数所继承的父类的构造函数\n * @param target\n * @constructor\n */\nexport function ParentConstructor<T extends Function = any>(target: T): IConstructor<any> | null\nexport function ParentConstructor<T extends Function = any>(target: IConstructor<T>): IConstructor<any> | null {\n    const rootProto: unknown = Symbol.constructor.prototype.constructor.__proto__\n    const constructor: Function = (!!target[Symbol.hasInstance] && target.prototype) ? target : target.constructor\n    const proto: IConstructor<any> = constructor.prototype.constructor.__proto__\n    return proto === rootProto ? null : proto\n}\n","import arrayify from 'array-back/index.mjs'\nimport t from 'typical/index.mjs'\n\n/**\n * Isomorphic, load-anywhere function to sort an array by scalar, deep or computed values in any standard or custom order.\n *\n * @module sort-array\n * @typicalname sortArray\n * @example\n * const sortArray = require('sort-array')\n */\n\n/**\n * @param {Array} array - The input array to sort. It is sorted in place.\n * @param {object} [options] - Sort options.\n * @param {string[]} [options.by] - One or more property names or computed fields to sort by. Specifying property names is only relevant when sorting an array of objects.\n * @param {string[]} [options.order] - One or more sort orders. Specify `'asc'`, `'desc'` or a property name from the `options.customOrders` object.\n * @param {object} [options.customOrders] - A dictionary object containing one or more custom orders. Each custom order value must be an array defining the order expected values must be sorted in.\n * @param {object} [options.computed] - A dictionary object containing one or more computed field functions. The function will be invoked once per item in the array. Each invocation will receive the array item as input and must return a primitive value by which the array can be sorted.\n * @param {number} [options.nullRank] - Configures whether `null` values will be sorted before or after defined values. Set to `-1` for before, `1` for after. Defaults to `1`.\n * @param {number} [options.undefinedRank] - Configures whether `undefined` values will be sorted before or after defined values. Set to `-1` for before, `1` for after. Defaults to `1`.\n * @returns {Array} Returns the array that was passed in.\n * @alias module:sort-array\n */\nfunction sortArray (arr, options = {}) {\n  options = Object.assign(\n    {\n      computed: {},\n      customOrders: {},\n      nullRank: 1,\n      undefinedRank: 1\n    },\n    options\n  )\n  arr.sort(getCompareFunc(options))\n  return arr\n}\n\nfunction getCompareFunc (options = {}) {\n  const by = arrayify(options.by)\n  const order = arrayify(options.order)\n  const { customOrders, computed } = options\n  return function compareFunc (xIn, yIn, byIndex = 0) {\n    const currOrder = order[byIndex] || 'asc'\n    if (!(currOrder === 'asc' || currOrder === 'desc' || customOrders[currOrder])) {\n      return 0\n    }\n\n    let result, x, y\n    if (by.length) {\n      x = t.isDefined(xIn[by[byIndex]])\n        ? xIn[by[byIndex]]\n        : computed[by[byIndex]] && computed[by[byIndex]](xIn)\n      y = t.isDefined(yIn[by[byIndex]])\n        ? yIn[by[byIndex]]\n        : computed[by[byIndex]] && computed[by[byIndex]](yIn)\n    } else {\n      x = xIn\n      y = yIn\n    }\n\n    if (customOrders && customOrders[currOrder]) {\n      result = customOrders[currOrder].indexOf(x) - customOrders[currOrder].indexOf(y)\n    } else if (x === y) {\n      result = 0\n    } else if (t.isNull(x) && t.isUndefined(y)) {\n      result = currOrder === 'asc'\n        ? 1\n        : currOrder === 'desc'\n          ? -1\n          : 0\n    } else if (t.isUndefined(x) && t.isNull(y)) {\n      result = currOrder === 'asc'\n        ? -1\n        : currOrder === 'desc'\n          ? 1\n          : 0\n    } else if (t.isNull(x) && t.isDefinedValue(y)) {\n      result = options.nullRank\n    } else if (t.isUndefined(x) && t.isDefinedValue(y)) {\n      result = options.undefinedRank\n    } else if (t.isNull(y) && t.isDefinedValue(x)) {\n      result = -options.nullRank\n    } else if (t.isUndefined(y) && t.isDefinedValue(x)) {\n      result = -options.undefinedRank\n    } else {\n      result = x < y ? -1 : x > y ? 1 : 0\n      if (currOrder === 'desc') {\n        result = result * -1\n      }\n    }\n    if (result === 0 && t.isDefined(by[byIndex + 1])) {\n      result = compareFunc(xIn, yIn, byIndex + 1)\n    }\n    return result\n  }\n}\n\nexport default sortArray\n","/**\n * Takes any input and guarantees an array back.\n *\n * - Converts array-like objects (e.g. `arguments`, `Set`) to a real array.\n * - Converts `undefined` to an empty array.\n * - Converts any another other, singular value (including `null`, objects and iterables other than `Set`) into an array containing that value.\n * - Ignores input which is already an array.\n *\n * @module array-back\n * @example\n * > const arrayify = require('array-back')\n *\n * > arrayify(undefined)\n * []\n *\n * > arrayify(null)\n * [ null ]\n *\n * > arrayify(0)\n * [ 0 ]\n *\n * > arrayify([ 1, 2 ])\n * [ 1, 2 ]\n *\n * > arrayify(new Set([ 1, 2 ]))\n * [ 1, 2 ]\n *\n * > function f(){ return arrayify(arguments); }\n * > f(1,2,3)\n * [ 1, 2, 3 ]\n */\n\nfunction isObject (input) {\n  return typeof input === 'object' && input !== null\n}\n\nfunction isArrayLike (input) {\n  return isObject(input) && typeof input.length === 'number'\n}\n\n/**\n * @param {*} - The input value to convert to an array\n * @returns {Array}\n * @alias module:array-back\n */\nfunction arrayify (input) {\n  if (Array.isArray(input)) {\n    return input\n  } else if (input === undefined) {\n    return []\n  } else if (isArrayLike(input) || input instanceof Set) {\n    return Array.from(input)\n  } else {\n    return [input]\n  }\n}\n\nexport default arrayify\n","/**\n * Isomorphic, functional type-checking for Javascript.\n * @module typical\n * @typicalname t\n * @example\n * const t = require('typical')\n * const allDefined = array.every(t.isDefined)\n */\n\n/**\n * Returns true if input is a number. It is a more reasonable alternative to `typeof n` which returns `number` for `NaN` and `Infinity`.\n *\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n * @example\n * > t.isNumber(0)\n * true\n * > t.isNumber(1)\n * true\n * > t.isNumber(1.1)\n * true\n * > t.isNumber(0xff)\n * true\n * > t.isNumber(0644)\n * true\n * > t.isNumber(6.2e5)\n * true\n * > t.isNumber(NaN)\n * false\n * > t.isNumber(Infinity)\n * false\n */\nexport function isNumber (n) {\n  return !isNaN(parseFloat(n)) && isFinite(n)\n}\n\n/**\n * A plain object is a simple object literal, it is not an instance of a class. Returns true if the input `typeof` is `object` and directly decends from `Object`.\n *\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n * @example\n * > t.isPlainObject({ something: 'one' })\n * true\n * > t.isPlainObject(new Date())\n * false\n * > t.isPlainObject([ 0, 1 ])\n * false\n * > t.isPlainObject(/test/)\n * false\n * > t.isPlainObject(1)\n * false\n * > t.isPlainObject('one')\n * false\n * > t.isPlainObject(null)\n * false\n * > t.isPlainObject((function * () {})())\n * false\n * > t.isPlainObject(function * () {})\n * false\n */\nexport function isPlainObject (input) {\n  return input !== null && typeof input === 'object' && input.constructor === Object\n}\n\n/**\n * An array-like value has all the properties of an array yet is not an array instance. An example is the `arguments` object. Returns `true`` if the input value is an object, not `null`` and has a `length` property set with a numeric value.\n *\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n * @example\n * function sum(x, y){\n *   console.log(t.isArrayLike(arguments))\n *   // prints `true`\n * }\n */\nexport function isArrayLike (input) {\n  return isObject(input) && typeof input.length === 'number'\n}\n\n/**\n * Returns true if the typeof input is `'object'` but not null.\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n */\nexport function isObject (input) {\n  return typeof input === 'object' && input !== null\n}\n\n/**\n * Returns true if the input value is defined.\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n */\nexport function isDefined (input) {\n  return typeof input !== 'undefined'\n}\n\n/**\n * Returns true if the input value is undefined.\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n */\nexport function isUndefined (input) {\n  return !isDefined(input)\n}\n\n/**\n * Returns true if the input value is null.\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n */\nexport function isNull (input) {\n return input === null\n}\n\n/**\n * Returns true if the input value is not one of `undefined`, `null`, or `NaN`.\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n */\nexport function isDefinedValue (input) {\n return isDefined(input) && !isNull(input) && !Number.isNaN(input)\n}\n\n/**\n * Returns true if the input value is an ES2015 `class`.\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n */\nexport function isClass (input) {\n  if (typeof input === 'function') {\n    return /^class /.test(Function.prototype.toString.call(input))\n  } else {\n    return false\n  }\n}\n\n/**\n * Returns true if the input is a string, number, symbol, boolean, null or undefined value.\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n */\nexport function isPrimitive (input) {\n  if (input === null) return true\n  switch (typeof input) {\n    case 'string':\n    case 'number':\n    case 'symbol':\n    case 'undefined':\n    case 'boolean':\n      return true\n    default:\n      return false\n  }\n}\n\n/**\n * Returns true if the input is a Promise.\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n */\nexport function isPromise (input) {\n  if (input) {\n    const isPromise = isDefined(Promise) && input instanceof Promise\n    const isThenable = input.then && typeof input.then === 'function'\n    return !!(isPromise || isThenable)\n  } else {\n    return false\n  }\n}\n\n/**\n * Returns true if the input is an iterable (`Map`, `Set`, `Array`, Generator etc.).\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n * @example\n * > t.isIterable('string')\n * true\n * > t.isIterable(new Map())\n * true\n * > t.isIterable([])\n * true\n * > t.isIterable((function * () {})())\n * true\n * > t.isIterable(Promise.resolve())\n * false\n * > t.isIterable(Promise)\n * false\n * > t.isIterable(true)\n * false\n * > t.isIterable({})\n * false\n * > t.isIterable(0)\n * false\n * > t.isIterable(1.1)\n * false\n * > t.isIterable(NaN)\n * false\n * > t.isIterable(Infinity)\n * false\n * > t.isIterable(function () {})\n * false\n * > t.isIterable(Date)\n * false\n * > t.isIterable()\n * false\n * > t.isIterable({ then: function () {} })\n * false\n */\nexport function isIterable (input) {\n  if (input === null || !isDefined(input)) {\n    return false\n  } else {\n    return (\n      typeof input[Symbol.iterator] === 'function' ||\n      typeof input[Symbol.asyncIterator] === 'function'\n    )\n  }\n}\n\n/**\n * Returns true if the input value is a string. The equivalent of `typeof input === 'string'` for use in funcitonal contexts.\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n */\nexport function isString (input) {\n  return typeof input === 'string'\n}\n\n/**\n * Returns true if the input value is a function. The equivalent of `typeof input === 'function'` for use in funcitonal contexts.\n * @param {*} - the input to test\n * @returns {boolean}\n * @static\n */\nexport function isFunction (input) {\n  return typeof input === 'function'\n}\n\nexport default {\n  isNumber,\n  isPlainObject,\n  isArrayLike,\n  isObject,\n  isDefined,\n  isUndefined,\n  isNull,\n  isDefinedValue,\n  isClass,\n  isPrimitive,\n  isPromise,\n  isIterable,\n  isString,\n  isFunction\n}\n","import isPlainObject from 'is-plain-obj';\n\nexport default function sortKeys(object, options = {}) {\n\tif (!isPlainObject(object) && !Array.isArray(object)) {\n\t\tthrow new TypeError('Expected a plain object or array');\n\t}\n\n\tconst {deep, compare} = options;\n\tconst seenInput = [];\n\tconst seenOutput = [];\n\n\tconst deepSortArray = array => {\n\t\tconst seenIndex = seenInput.indexOf(array);\n\t\tif (seenIndex !== -1) {\n\t\t\treturn seenOutput[seenIndex];\n\t\t}\n\n\t\tconst result = [];\n\t\tseenInput.push(array);\n\t\tseenOutput.push(result);\n\n\t\tresult.push(...array.map(item => {\n\t\t\tif (Array.isArray(item)) {\n\t\t\t\treturn deepSortArray(item);\n\t\t\t}\n\n\t\t\tif (isPlainObject(item)) {\n\t\t\t\treturn _sortKeys(item);\n\t\t\t}\n\n\t\t\treturn item;\n\t\t}));\n\n\t\treturn result;\n\t};\n\n\tconst _sortKeys = object => {\n\t\tconst seenIndex = seenInput.indexOf(object);\n\t\tif (seenIndex !== -1) {\n\t\t\treturn seenOutput[seenIndex];\n\t\t}\n\n\t\tconst result = {};\n\t\tconst keys = Object.keys(object).sort(compare);\n\n\t\tseenInput.push(object);\n\t\tseenOutput.push(result);\n\n\t\tfor (const key of keys) {\n\t\t\tconst value = object[key];\n\t\t\tlet newValue;\n\n\t\t\tif (deep && Array.isArray(value)) {\n\t\t\t\tnewValue = deepSortArray(value);\n\t\t\t} else {\n\t\t\t\tnewValue = deep && isPlainObject(value) ? _sortKeys(value) : value;\n\t\t\t}\n\n\t\t\tObject.defineProperty(result, key, {\n\t\t\t\t...Object.getOwnPropertyDescriptor(object, key),\n\t\t\t\tvalue: newValue\n\t\t\t});\n\t\t}\n\n\t\treturn result;\n\t};\n\n\tif (Array.isArray(object)) {\n\t\treturn deep ? deepSortArray(object) : object.slice();\n\t}\n\n\treturn _sortKeys(object);\n}\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n"]}