first commit

1 files changed, 4174 insertions, 0 deletions

diff --git a/node_modules/@sapphire/shapeshift/dist/index.global.js b/node_modules/@sapphire/shapeshift/dist/index.global.js
new file mode 100644
index 0000000..0f48b8a
--- /dev/null
+++ b/node_modules/@sapphire/shapeshift/dist/index.global.js
@@ -0,0 +1,4174 @@
+var SapphireShapeshift = (function (exports) {
+  'use strict';
+
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // node_modules/lodash/isArray.js
+  var require_isArray = __commonJS({
+    "node_modules/lodash/isArray.js"(exports, module) {
+      var isArray3 = Array.isArray;
+      module.exports = isArray3;
+    }
+  });
+
+  // node_modules/lodash/_freeGlobal.js
+  var require_freeGlobal = __commonJS({
+    "node_modules/lodash/_freeGlobal.js"(exports, module) {
+      var freeGlobal = typeof globalThis == "object" && globalThis && globalThis.Object === Object && globalThis;
+      module.exports = freeGlobal;
+    }
+  });
+
+  // node_modules/lodash/_root.js
+  var require_root = __commonJS({
+    "node_modules/lodash/_root.js"(exports, module) {
+      var freeGlobal = require_freeGlobal();
+      var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+      var root = freeGlobal || freeSelf || Function("return this")();
+      module.exports = root;
+    }
+  });
+
+  // node_modules/lodash/_Symbol.js
+  var require_Symbol = __commonJS({
+    "node_modules/lodash/_Symbol.js"(exports, module) {
+      var root = require_root();
+      var Symbol2 = root.Symbol;
+      module.exports = Symbol2;
+    }
+  });
+
+  // node_modules/lodash/_getRawTag.js
+  var require_getRawTag = __commonJS({
+    "node_modules/lodash/_getRawTag.js"(exports, module) {
+      var Symbol2 = require_Symbol();
+      var objectProto = Object.prototype;
+      var hasOwnProperty = objectProto.hasOwnProperty;
+      var nativeObjectToString = objectProto.toString;
+      var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+      function getRawTag(value) {
+        var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+        try {
+          value[symToStringTag] = void 0;
+          var unmasked = true;
+        } catch (e3) {
+        }
+        var result = nativeObjectToString.call(value);
+        if (unmasked) {
+          if (isOwn) {
+            value[symToStringTag] = tag;
+          } else {
+            delete value[symToStringTag];
+          }
+        }
+        return result;
+      }
+      __name(getRawTag, "getRawTag");
+      module.exports = getRawTag;
+    }
+  });
+
+  // node_modules/lodash/_objectToString.js
+  var require_objectToString = __commonJS({
+    "node_modules/lodash/_objectToString.js"(exports, module) {
+      var objectProto = Object.prototype;
+      var nativeObjectToString = objectProto.toString;
+      function objectToString(value) {
+        return nativeObjectToString.call(value);
+      }
+      __name(objectToString, "objectToString");
+      module.exports = objectToString;
+    }
+  });
+
+  // node_modules/lodash/_baseGetTag.js
+  var require_baseGetTag = __commonJS({
+    "node_modules/lodash/_baseGetTag.js"(exports, module) {
+      var Symbol2 = require_Symbol();
+      var getRawTag = require_getRawTag();
+      var objectToString = require_objectToString();
+      var nullTag = "[object Null]";
+      var undefinedTag = "[object Undefined]";
+      var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+      function baseGetTag(value) {
+        if (value == null) {
+          return value === void 0 ? undefinedTag : nullTag;
+        }
+        return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+      }
+      __name(baseGetTag, "baseGetTag");
+      module.exports = baseGetTag;
+    }
+  });
+
+  // node_modules/lodash/isObjectLike.js
+  var require_isObjectLike = __commonJS({
+    "node_modules/lodash/isObjectLike.js"(exports, module) {
+      function isObjectLike(value) {
+        return value != null && typeof value == "object";
+      }
+      __name(isObjectLike, "isObjectLike");
+      module.exports = isObjectLike;
+    }
+  });
+
+  // node_modules/lodash/isSymbol.js
+  var require_isSymbol = __commonJS({
+    "node_modules/lodash/isSymbol.js"(exports, module) {
+      var baseGetTag = require_baseGetTag();
+      var isObjectLike = require_isObjectLike();
+      var symbolTag = "[object Symbol]";
+      function isSymbol3(value) {
+        return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+      }
+      __name(isSymbol3, "isSymbol");
+      module.exports = isSymbol3;
+    }
+  });
+
+  // node_modules/lodash/_isKey.js
+  var require_isKey = __commonJS({
+    "node_modules/lodash/_isKey.js"(exports, module) {
+      var isArray3 = require_isArray();
+      var isSymbol3 = require_isSymbol();
+      var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+      var reIsPlainProp = /^\w*$/;
+      function isKey(value, object) {
+        if (isArray3(value)) {
+          return false;
+        }
+        var type = typeof value;
+        if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol3(value)) {
+          return true;
+        }
+        return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+      }
+      __name(isKey, "isKey");
+      module.exports = isKey;
+    }
+  });
+
+  // node_modules/lodash/isObject.js
+  var require_isObject = __commonJS({
+    "node_modules/lodash/isObject.js"(exports, module) {
+      function isObject3(value) {
+        var type = typeof value;
+        return value != null && (type == "object" || type == "function");
+      }
+      __name(isObject3, "isObject");
+      module.exports = isObject3;
+    }
+  });
+
+  // node_modules/lodash/isFunction.js
+  var require_isFunction = __commonJS({
+    "node_modules/lodash/isFunction.js"(exports, module) {
+      var baseGetTag = require_baseGetTag();
+      var isObject3 = require_isObject();
+      var asyncTag = "[object AsyncFunction]";
+      var funcTag = "[object Function]";
+      var genTag = "[object GeneratorFunction]";
+      var proxyTag = "[object Proxy]";
+      function isFunction3(value) {
+        if (!isObject3(value)) {
+          return false;
+        }
+        var tag = baseGetTag(value);
+        return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+      }
+      __name(isFunction3, "isFunction");
+      module.exports = isFunction3;
+    }
+  });
+
+  // node_modules/lodash/_coreJsData.js
+  var require_coreJsData = __commonJS({
+    "node_modules/lodash/_coreJsData.js"(exports, module) {
+      var root = require_root();
+      var coreJsData = root["__core-js_shared__"];
+      module.exports = coreJsData;
+    }
+  });
+
+  // node_modules/lodash/_isMasked.js
+  var require_isMasked = __commonJS({
+    "node_modules/lodash/_isMasked.js"(exports, module) {
+      var coreJsData = require_coreJsData();
+      var maskSrcKey = function() {
+        var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+        return uid ? "Symbol(src)_1." + uid : "";
+      }();
+      function isMasked(func) {
+        return !!maskSrcKey && maskSrcKey in func;
+      }
+      __name(isMasked, "isMasked");
+      module.exports = isMasked;
+    }
+  });
+
+  // node_modules/lodash/_toSource.js
+  var require_toSource = __commonJS({
+    "node_modules/lodash/_toSource.js"(exports, module) {
+      var funcProto = Function.prototype;
+      var funcToString = funcProto.toString;
+      function toSource(func) {
+        if (func != null) {
+          try {
+            return funcToString.call(func);
+          } catch (e3) {
+          }
+          try {
+            return func + "";
+          } catch (e3) {
+          }
+        }
+        return "";
+      }
+      __name(toSource, "toSource");
+      module.exports = toSource;
+    }
+  });
+
+  // node_modules/lodash/_baseIsNative.js
+  var require_baseIsNative = __commonJS({
+    "node_modules/lodash/_baseIsNative.js"(exports, module) {
+      var isFunction3 = require_isFunction();
+      var isMasked = require_isMasked();
+      var isObject3 = require_isObject();
+      var toSource = require_toSource();
+      var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+      var reIsHostCtor = /^\[object .+?Constructor\]$/;
+      var funcProto = Function.prototype;
+      var objectProto = Object.prototype;
+      var funcToString = funcProto.toString;
+      var hasOwnProperty = objectProto.hasOwnProperty;
+      var reIsNative = RegExp(
+        "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+      );
+      function baseIsNative(value) {
+        if (!isObject3(value) || isMasked(value)) {
+          return false;
+        }
+        var pattern = isFunction3(value) ? reIsNative : reIsHostCtor;
+        return pattern.test(toSource(value));
+      }
+      __name(baseIsNative, "baseIsNative");
+      module.exports = baseIsNative;
+    }
+  });
+
+  // node_modules/lodash/_getValue.js
+  var require_getValue = __commonJS({
+    "node_modules/lodash/_getValue.js"(exports, module) {
+      function getValue2(object, key) {
+        return object == null ? void 0 : object[key];
+      }
+      __name(getValue2, "getValue");
+      module.exports = getValue2;
+    }
+  });
+
+  // node_modules/lodash/_getNative.js
+  var require_getNative = __commonJS({
+    "node_modules/lodash/_getNative.js"(exports, module) {
+      var baseIsNative = require_baseIsNative();
+      var getValue2 = require_getValue();
+      function getNative(object, key) {
+        var value = getValue2(object, key);
+        return baseIsNative(value) ? value : void 0;
+      }
+      __name(getNative, "getNative");
+      module.exports = getNative;
+    }
+  });
+
+  // node_modules/lodash/_nativeCreate.js
+  var require_nativeCreate = __commonJS({
+    "node_modules/lodash/_nativeCreate.js"(exports, module) {
+      var getNative = require_getNative();
+      var nativeCreate = getNative(Object, "create");
+      module.exports = nativeCreate;
+    }
+  });
+
+  // node_modules/lodash/_hashClear.js
+  var require_hashClear = __commonJS({
+    "node_modules/lodash/_hashClear.js"(exports, module) {
+      var nativeCreate = require_nativeCreate();
+      function hashClear() {
+        this.__data__ = nativeCreate ? nativeCreate(null) : {};
+        this.size = 0;
+      }
+      __name(hashClear, "hashClear");
+      module.exports = hashClear;
+    }
+  });
+
+  // node_modules/lodash/_hashDelete.js
+  var require_hashDelete = __commonJS({
+    "node_modules/lodash/_hashDelete.js"(exports, module) {
+      function hashDelete(key) {
+        var result = this.has(key) && delete this.__data__[key];
+        this.size -= result ? 1 : 0;
+        return result;
+      }
+      __name(hashDelete, "hashDelete");
+      module.exports = hashDelete;
+    }
+  });
+
+  // node_modules/lodash/_hashGet.js
+  var require_hashGet = __commonJS({
+    "node_modules/lodash/_hashGet.js"(exports, module) {
+      var nativeCreate = require_nativeCreate();
+      var HASH_UNDEFINED = "__lodash_hash_undefined__";
+      var objectProto = Object.prototype;
+      var hasOwnProperty = objectProto.hasOwnProperty;
+      function hashGet(key) {
+        var data = this.__data__;
+        if (nativeCreate) {
+          var result = data[key];
+          return result === HASH_UNDEFINED ? void 0 : result;
+        }
+        return hasOwnProperty.call(data, key) ? data[key] : void 0;
+      }
+      __name(hashGet, "hashGet");
+      module.exports = hashGet;
+    }
+  });
+
+  // node_modules/lodash/_hashHas.js
+  var require_hashHas = __commonJS({
+    "node_modules/lodash/_hashHas.js"(exports, module) {
+      var nativeCreate = require_nativeCreate();
+      var objectProto = Object.prototype;
+      var hasOwnProperty = objectProto.hasOwnProperty;
+      function hashHas(key) {
+        var data = this.__data__;
+        return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+      }
+      __name(hashHas, "hashHas");
+      module.exports = hashHas;
+    }
+  });
+
+  // node_modules/lodash/_hashSet.js
+  var require_hashSet = __commonJS({
+    "node_modules/lodash/_hashSet.js"(exports, module) {
+      var nativeCreate = require_nativeCreate();
+      var HASH_UNDEFINED = "__lodash_hash_undefined__";
+      function hashSet(key, value) {
+        var data = this.__data__;
+        this.size += this.has(key) ? 0 : 1;
+        data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+        return this;
+      }
+      __name(hashSet, "hashSet");
+      module.exports = hashSet;
+    }
+  });
+
+  // node_modules/lodash/_Hash.js
+  var require_Hash = __commonJS({
+    "node_modules/lodash/_Hash.js"(exports, module) {
+      var hashClear = require_hashClear();
+      var hashDelete = require_hashDelete();
+      var hashGet = require_hashGet();
+      var hashHas = require_hashHas();
+      var hashSet = require_hashSet();
+      function Hash(entries) {
+        var index = -1, length = entries == null ? 0 : entries.length;
+        this.clear();
+        while (++index < length) {
+          var entry = entries[index];
+          this.set(entry[0], entry[1]);
+        }
+      }
+      __name(Hash, "Hash");
+      Hash.prototype.clear = hashClear;
+      Hash.prototype["delete"] = hashDelete;
+      Hash.prototype.get = hashGet;
+      Hash.prototype.has = hashHas;
+      Hash.prototype.set = hashSet;
+      module.exports = Hash;
+    }
+  });
+
+  // node_modules/lodash/_listCacheClear.js
+  var require_listCacheClear = __commonJS({
+    "node_modules/lodash/_listCacheClear.js"(exports, module) {
+      function listCacheClear() {
+        this.__data__ = [];
+        this.size = 0;
+      }
+      __name(listCacheClear, "listCacheClear");
+      module.exports = listCacheClear;
+    }
+  });
+
+  // node_modules/lodash/eq.js
+  var require_eq = __commonJS({
+    "node_modules/lodash/eq.js"(exports, module) {
+      function eq(value, other) {
+        return value === other || value !== value && other !== other;
+      }
+      __name(eq, "eq");
+      module.exports = eq;
+    }
+  });
+
+  // node_modules/lodash/_assocIndexOf.js
+  var require_assocIndexOf = __commonJS({
+    "node_modules/lodash/_assocIndexOf.js"(exports, module) {
+      var eq = require_eq();
+      function assocIndexOf(array, key) {
+        var length = array.length;
+        while (length--) {
+          if (eq(array[length][0], key)) {
+            return length;
+          }
+        }
+        return -1;
+      }
+      __name(assocIndexOf, "assocIndexOf");
+      module.exports = assocIndexOf;
+    }
+  });
+
+  // node_modules/lodash/_listCacheDelete.js
+  var require_listCacheDelete = __commonJS({
+    "node_modules/lodash/_listCacheDelete.js"(exports, module) {
+      var assocIndexOf = require_assocIndexOf();
+      var arrayProto = Array.prototype;
+      var splice = arrayProto.splice;
+      function listCacheDelete(key) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        if (index < 0) {
+          return false;
+        }
+        var lastIndex = data.length - 1;
+        if (index == lastIndex) {
+          data.pop();
+        } else {
+          splice.call(data, index, 1);
+        }
+        --this.size;
+        return true;
+      }
+      __name(listCacheDelete, "listCacheDelete");
+      module.exports = listCacheDelete;
+    }
+  });
+
+  // node_modules/lodash/_listCacheGet.js
+  var require_listCacheGet = __commonJS({
+    "node_modules/lodash/_listCacheGet.js"(exports, module) {
+      var assocIndexOf = require_assocIndexOf();
+      function listCacheGet(key) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        return index < 0 ? void 0 : data[index][1];
+      }
+      __name(listCacheGet, "listCacheGet");
+      module.exports = listCacheGet;
+    }
+  });
+
+  // node_modules/lodash/_listCacheHas.js
+  var require_listCacheHas = __commonJS({
+    "node_modules/lodash/_listCacheHas.js"(exports, module) {
+      var assocIndexOf = require_assocIndexOf();
+      function listCacheHas(key) {
+        return assocIndexOf(this.__data__, key) > -1;
+      }
+      __name(listCacheHas, "listCacheHas");
+      module.exports = listCacheHas;
+    }
+  });
+
+  // node_modules/lodash/_listCacheSet.js
+  var require_listCacheSet = __commonJS({
+    "node_modules/lodash/_listCacheSet.js"(exports, module) {
+      var assocIndexOf = require_assocIndexOf();
+      function listCacheSet(key, value) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        if (index < 0) {
+          ++this.size;
+          data.push([key, value]);
+        } else {
+          data[index][1] = value;
+        }
+        return this;
+      }
+      __name(listCacheSet, "listCacheSet");
+      module.exports = listCacheSet;
+    }
+  });
+
+  // node_modules/lodash/_ListCache.js
+  var require_ListCache = __commonJS({
+    "node_modules/lodash/_ListCache.js"(exports, module) {
+      var listCacheClear = require_listCacheClear();
+      var listCacheDelete = require_listCacheDelete();
+      var listCacheGet = require_listCacheGet();
+      var listCacheHas = require_listCacheHas();
+      var listCacheSet = require_listCacheSet();
+      function ListCache(entries) {
+        var index = -1, length = entries == null ? 0 : entries.length;
+        this.clear();
+        while (++index < length) {
+          var entry = entries[index];
+          this.set(entry[0], entry[1]);
+        }
+      }
+      __name(ListCache, "ListCache");
+      ListCache.prototype.clear = listCacheClear;
+      ListCache.prototype["delete"] = listCacheDelete;
+      ListCache.prototype.get = listCacheGet;
+      ListCache.prototype.has = listCacheHas;
+      ListCache.prototype.set = listCacheSet;
+      module.exports = ListCache;
+    }
+  });
+
+  // node_modules/lodash/_Map.js
+  var require_Map = __commonJS({
+    "node_modules/lodash/_Map.js"(exports, module) {
+      var getNative = require_getNative();
+      var root = require_root();
+      var Map2 = getNative(root, "Map");
+      module.exports = Map2;
+    }
+  });
+
+  // node_modules/lodash/_mapCacheClear.js
+  var require_mapCacheClear = __commonJS({
+    "node_modules/lodash/_mapCacheClear.js"(exports, module) {
+      var Hash = require_Hash();
+      var ListCache = require_ListCache();
+      var Map2 = require_Map();
+      function mapCacheClear() {
+        this.size = 0;
+        this.__data__ = {
+          "hash": new Hash(),
+          "map": new (Map2 || ListCache)(),
+          "string": new Hash()
+        };
+      }
+      __name(mapCacheClear, "mapCacheClear");
+      module.exports = mapCacheClear;
+    }
+  });
+
+  // node_modules/lodash/_isKeyable.js
+  var require_isKeyable = __commonJS({
+    "node_modules/lodash/_isKeyable.js"(exports, module) {
+      function isKeyable(value) {
+        var type = typeof value;
+        return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+      }
+      __name(isKeyable, "isKeyable");
+      module.exports = isKeyable;
+    }
+  });
+
+  // node_modules/lodash/_getMapData.js
+  var require_getMapData = __commonJS({
+    "node_modules/lodash/_getMapData.js"(exports, module) {
+      var isKeyable = require_isKeyable();
+      function getMapData(map, key) {
+        var data = map.__data__;
+        return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+      }
+      __name(getMapData, "getMapData");
+      module.exports = getMapData;
+    }
+  });
+
+  // node_modules/lodash/_mapCacheDelete.js
+  var require_mapCacheDelete = __commonJS({
+    "node_modules/lodash/_mapCacheDelete.js"(exports, module) {
+      var getMapData = require_getMapData();
+      function mapCacheDelete(key) {
+        var result = getMapData(this, key)["delete"](key);
+        this.size -= result ? 1 : 0;
+        return result;
+      }
+      __name(mapCacheDelete, "mapCacheDelete");
+      module.exports = mapCacheDelete;
+    }
+  });
+
+  // node_modules/lodash/_mapCacheGet.js
+  var require_mapCacheGet = __commonJS({
+    "node_modules/lodash/_mapCacheGet.js"(exports, module) {
+      var getMapData = require_getMapData();
+      function mapCacheGet(key) {
+        return getMapData(this, key).get(key);
+      }
+      __name(mapCacheGet, "mapCacheGet");
+      module.exports = mapCacheGet;
+    }
+  });
+
+  // node_modules/lodash/_mapCacheHas.js
+  var require_mapCacheHas = __commonJS({
+    "node_modules/lodash/_mapCacheHas.js"(exports, module) {
+      var getMapData = require_getMapData();
+      function mapCacheHas(key) {
+        return getMapData(this, key).has(key);
+      }
+      __name(mapCacheHas, "mapCacheHas");
+      module.exports = mapCacheHas;
+    }
+  });
+
+  // node_modules/lodash/_mapCacheSet.js
+  var require_mapCacheSet = __commonJS({
+    "node_modules/lodash/_mapCacheSet.js"(exports, module) {
+      var getMapData = require_getMapData();
+      function mapCacheSet(key, value) {
+        var data = getMapData(this, key), size = data.size;
+        data.set(key, value);
+        this.size += data.size == size ? 0 : 1;
+        return this;
+      }
+      __name(mapCacheSet, "mapCacheSet");
+      module.exports = mapCacheSet;
+    }
+  });
+
+  // node_modules/lodash/_MapCache.js
+  var require_MapCache = __commonJS({
+    "node_modules/lodash/_MapCache.js"(exports, module) {
+      var mapCacheClear = require_mapCacheClear();
+      var mapCacheDelete = require_mapCacheDelete();
+      var mapCacheGet = require_mapCacheGet();
+      var mapCacheHas = require_mapCacheHas();
+      var mapCacheSet = require_mapCacheSet();
+      function MapCache(entries) {
+        var index = -1, length = entries == null ? 0 : entries.length;
+        this.clear();
+        while (++index < length) {
+          var entry = entries[index];
+          this.set(entry[0], entry[1]);
+        }
+      }
+      __name(MapCache, "MapCache");
+      MapCache.prototype.clear = mapCacheClear;
+      MapCache.prototype["delete"] = mapCacheDelete;
+      MapCache.prototype.get = mapCacheGet;
+      MapCache.prototype.has = mapCacheHas;
+      MapCache.prototype.set = mapCacheSet;
+      module.exports = MapCache;
+    }
+  });
+
+  // node_modules/lodash/memoize.js
+  var require_memoize = __commonJS({
+    "node_modules/lodash/memoize.js"(exports, module) {
+      var MapCache = require_MapCache();
+      var FUNC_ERROR_TEXT = "Expected a function";
+      function memoize(func, resolver) {
+        if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+          throw new TypeError(FUNC_ERROR_TEXT);
+        }
+        var memoized = /* @__PURE__ */ __name(function() {
+          var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+          if (cache.has(key)) {
+            return cache.get(key);
+          }
+          var result = func.apply(this, args);
+          memoized.cache = cache.set(key, result) || cache;
+          return result;
+        }, "memoized");
+        memoized.cache = new (memoize.Cache || MapCache)();
+        return memoized;
+      }
+      __name(memoize, "memoize");
+      memoize.Cache = MapCache;
+      module.exports = memoize;
+    }
+  });
+
+  // node_modules/lodash/_memoizeCapped.js
+  var require_memoizeCapped = __commonJS({
+    "node_modules/lodash/_memoizeCapped.js"(exports, module) {
+      var memoize = require_memoize();
+      var MAX_MEMOIZE_SIZE = 500;
+      function memoizeCapped(func) {
+        var result = memoize(func, function(key) {
+          if (cache.size === MAX_MEMOIZE_SIZE) {
+            cache.clear();
+          }
+          return key;
+        });
+        var cache = result.cache;
+        return result;
+      }
+      __name(memoizeCapped, "memoizeCapped");
+      module.exports = memoizeCapped;
+    }
+  });
+
+  // node_modules/lodash/_stringToPath.js
+  var require_stringToPath = __commonJS({
+    "node_modules/lodash/_stringToPath.js"(exports, module) {
+      var memoizeCapped = require_memoizeCapped();
+      var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+      var reEscapeChar = /\\(\\)?/g;
+      var stringToPath = memoizeCapped(function(string) {
+        var result = [];
+        if (string.charCodeAt(0) === 46) {
+          result.push("");
+        }
+        string.replace(rePropName, function(match, number, quote, subString) {
+          result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+        });
+        return result;
+      });
+      module.exports = stringToPath;
+    }
+  });
+
+  // node_modules/lodash/_arrayMap.js
+  var require_arrayMap = __commonJS({
+    "node_modules/lodash/_arrayMap.js"(exports, module) {
+      function arrayMap(array, iteratee) {
+        var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+        while (++index < length) {
+          result[index] = iteratee(array[index], index, array);
+        }
+        return result;
+      }
+      __name(arrayMap, "arrayMap");
+      module.exports = arrayMap;
+    }
+  });
+
+  // node_modules/lodash/_baseToString.js
+  var require_baseToString = __commonJS({
+    "node_modules/lodash/_baseToString.js"(exports, module) {
+      var Symbol2 = require_Symbol();
+      var arrayMap = require_arrayMap();
+      var isArray3 = require_isArray();
+      var isSymbol3 = require_isSymbol();
+      var INFINITY = 1 / 0;
+      var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
+      var symbolToString = symbolProto ? symbolProto.toString : void 0;
+      function baseToString(value) {
+        if (typeof value == "string") {
+          return value;
+        }
+        if (isArray3(value)) {
+          return arrayMap(value, baseToString) + "";
+        }
+        if (isSymbol3(value)) {
+          return symbolToString ? symbolToString.call(value) : "";
+        }
+        var result = value + "";
+        return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+      }
+      __name(baseToString, "baseToString");
+      module.exports = baseToString;
+    }
+  });
+
+  // node_modules/lodash/toString.js
+  var require_toString = __commonJS({
+    "node_modules/lodash/toString.js"(exports, module) {
+      var baseToString = require_baseToString();
+      function toString(value) {
+        return value == null ? "" : baseToString(value);
+      }
+      __name(toString, "toString");
+      module.exports = toString;
+    }
+  });
+
+  // node_modules/lodash/_castPath.js
+  var require_castPath = __commonJS({
+    "node_modules/lodash/_castPath.js"(exports, module) {
+      var isArray3 = require_isArray();
+      var isKey = require_isKey();
+      var stringToPath = require_stringToPath();
+      var toString = require_toString();
+      function castPath(value, object) {
+        if (isArray3(value)) {
+          return value;
+        }
+        return isKey(value, object) ? [value] : stringToPath(toString(value));
+      }
+      __name(castPath, "castPath");
+      module.exports = castPath;
+    }
+  });
+
+  // node_modules/lodash/_toKey.js
+  var require_toKey = __commonJS({
+    "node_modules/lodash/_toKey.js"(exports, module) {
+      var isSymbol3 = require_isSymbol();
+      var INFINITY = 1 / 0;
+      function toKey(value) {
+        if (typeof value == "string" || isSymbol3(value)) {
+          return value;
+        }
+        var result = value + "";
+        return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+      }
+      __name(toKey, "toKey");
+      module.exports = toKey;
+    }
+  });
+
+  // node_modules/lodash/_baseGet.js
+  var require_baseGet = __commonJS({
+    "node_modules/lodash/_baseGet.js"(exports, module) {
+      var castPath = require_castPath();
+      var toKey = require_toKey();
+      function baseGet(object, path) {
+        path = castPath(path, object);
+        var index = 0, length = path.length;
+        while (object != null && index < length) {
+          object = object[toKey(path[index++])];
+        }
+        return index && index == length ? object : void 0;
+      }
+      __name(baseGet, "baseGet");
+      module.exports = baseGet;
+    }
+  });
+
+  // node_modules/lodash/get.js
+  var require_get = __commonJS({
+    "node_modules/lodash/get.js"(exports, module) {
+      var baseGet = require_baseGet();
+      function get2(object, path, defaultValue) {
+        var result = object == null ? void 0 : baseGet(object, path);
+        return result === void 0 ? defaultValue : result;
+      }
+      __name(get2, "get");
+      module.exports = get2;
+    }
+  });
+
+  // node_modules/fast-deep-equal/es6/index.js
+  var require_es6 = __commonJS({
+    "node_modules/fast-deep-equal/es6/index.js"(exports, module) {
+      module.exports = /* @__PURE__ */ __name(function equal2(a3, b2) {
+        if (a3 === b2)
+          return true;
+        if (a3 && b2 && typeof a3 == "object" && typeof b2 == "object") {
+          if (a3.constructor !== b2.constructor)
+            return false;
+          var length, i3, keys;
+          if (Array.isArray(a3)) {
+            length = a3.length;
+            if (length != b2.length)
+              return false;
+            for (i3 = length; i3-- !== 0; )
+              if (!equal2(a3[i3], b2[i3]))
+                return false;
+            return true;
+          }
+          if (a3 instanceof Map && b2 instanceof Map) {
+            if (a3.size !== b2.size)
+              return false;
+            for (i3 of a3.entries())
+              if (!b2.has(i3[0]))
+                return false;
+            for (i3 of a3.entries())
+              if (!equal2(i3[1], b2.get(i3[0])))
+                return false;
+            return true;
+          }
+          if (a3 instanceof Set && b2 instanceof Set) {
+            if (a3.size !== b2.size)
+              return false;
+            for (i3 of a3.entries())
+              if (!b2.has(i3[0]))
+                return false;
+            return true;
+          }
+          if (ArrayBuffer.isView(a3) && ArrayBuffer.isView(b2)) {
+            length = a3.length;
+            if (length != b2.length)
+              return false;
+            for (i3 = length; i3-- !== 0; )
+              if (a3[i3] !== b2[i3])
+                return false;
+            return true;
+          }
+          if (a3.constructor === RegExp)
+            return a3.source === b2.source && a3.flags === b2.flags;
+          if (a3.valueOf !== Object.prototype.valueOf)
+            return a3.valueOf() === b2.valueOf();
+          if (a3.toString !== Object.prototype.toString)
+            return a3.toString() === b2.toString();
+          keys = Object.keys(a3);
+          length = keys.length;
+          if (length !== Object.keys(b2).length)
+            return false;
+          for (i3 = length; i3-- !== 0; )
+            if (!Object.prototype.hasOwnProperty.call(b2, keys[i3]))
+              return false;
+          for (i3 = length; i3-- !== 0; ) {
+            var key = keys[i3];
+            if (!equal2(a3[key], b2[key]))
+              return false;
+          }
+          return true;
+        }
+        return a3 !== a3 && b2 !== b2;
+      }, "equal");
+    }
+  });
+
+  // node_modules/lodash/_setCacheAdd.js
+  var require_setCacheAdd = __commonJS({
+    "node_modules/lodash/_setCacheAdd.js"(exports, module) {
+      var HASH_UNDEFINED = "__lodash_hash_undefined__";
+      function setCacheAdd(value) {
+        this.__data__.set(value, HASH_UNDEFINED);
+        return this;
+      }
+      __name(setCacheAdd, "setCacheAdd");
+      module.exports = setCacheAdd;
+    }
+  });
+
+  // node_modules/lodash/_setCacheHas.js
+  var require_setCacheHas = __commonJS({
+    "node_modules/lodash/_setCacheHas.js"(exports, module) {
+      function setCacheHas(value) {
+        return this.__data__.has(value);
+      }
+      __name(setCacheHas, "setCacheHas");
+      module.exports = setCacheHas;
+    }
+  });
+
+  // node_modules/lodash/_SetCache.js
+  var require_SetCache = __commonJS({
+    "node_modules/lodash/_SetCache.js"(exports, module) {
+      var MapCache = require_MapCache();
+      var setCacheAdd = require_setCacheAdd();
+      var setCacheHas = require_setCacheHas();
+      function SetCache(values) {
+        var index = -1, length = values == null ? 0 : values.length;
+        this.__data__ = new MapCache();
+        while (++index < length) {
+          this.add(values[index]);
+        }
+      }
+      __name(SetCache, "SetCache");
+      SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+      SetCache.prototype.has = setCacheHas;
+      module.exports = SetCache;
+    }
+  });
+
+  // node_modules/lodash/_baseFindIndex.js
+  var require_baseFindIndex = __commonJS({
+    "node_modules/lodash/_baseFindIndex.js"(exports, module) {
+      function baseFindIndex(array, predicate, fromIndex, fromRight) {
+        var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
+        while (fromRight ? index-- : ++index < length) {
+          if (predicate(array[index], index, array)) {
+            return index;
+          }
+        }
+        return -1;
+      }
+      __name(baseFindIndex, "baseFindIndex");
+      module.exports = baseFindIndex;
+    }
+  });
+
+  // node_modules/lodash/_baseIsNaN.js
+  var require_baseIsNaN = __commonJS({
+    "node_modules/lodash/_baseIsNaN.js"(exports, module) {
+      function baseIsNaN(value) {
+        return value !== value;
+      }
+      __name(baseIsNaN, "baseIsNaN");
+      module.exports = baseIsNaN;
+    }
+  });
+
+  // node_modules/lodash/_strictIndexOf.js
+  var require_strictIndexOf = __commonJS({
+    "node_modules/lodash/_strictIndexOf.js"(exports, module) {
+      function strictIndexOf(array, value, fromIndex) {
+        var index = fromIndex - 1, length = array.length;
+        while (++index < length) {
+          if (array[index] === value) {
+            return index;
+          }
+        }
+        return -1;
+      }
+      __name(strictIndexOf, "strictIndexOf");
+      module.exports = strictIndexOf;
+    }
+  });
+
+  // node_modules/lodash/_baseIndexOf.js
+  var require_baseIndexOf = __commonJS({
+    "node_modules/lodash/_baseIndexOf.js"(exports, module) {
+      var baseFindIndex = require_baseFindIndex();
+      var baseIsNaN = require_baseIsNaN();
+      var strictIndexOf = require_strictIndexOf();
+      function baseIndexOf(array, value, fromIndex) {
+        return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
+      }
+      __name(baseIndexOf, "baseIndexOf");
+      module.exports = baseIndexOf;
+    }
+  });
+
+  // node_modules/lodash/_arrayIncludes.js
+  var require_arrayIncludes = __commonJS({
+    "node_modules/lodash/_arrayIncludes.js"(exports, module) {
+      var baseIndexOf = require_baseIndexOf();
+      function arrayIncludes(array, value) {
+        var length = array == null ? 0 : array.length;
+        return !!length && baseIndexOf(array, value, 0) > -1;
+      }
+      __name(arrayIncludes, "arrayIncludes");
+      module.exports = arrayIncludes;
+    }
+  });
+
+  // node_modules/lodash/_arrayIncludesWith.js
+  var require_arrayIncludesWith = __commonJS({
+    "node_modules/lodash/_arrayIncludesWith.js"(exports, module) {
+      function arrayIncludesWith(array, value, comparator) {
+        var index = -1, length = array == null ? 0 : array.length;
+        while (++index < length) {
+          if (comparator(value, array[index])) {
+            return true;
+          }
+        }
+        return false;
+      }
+      __name(arrayIncludesWith, "arrayIncludesWith");
+      module.exports = arrayIncludesWith;
+    }
+  });
+
+  // node_modules/lodash/_cacheHas.js
+  var require_cacheHas = __commonJS({
+    "node_modules/lodash/_cacheHas.js"(exports, module) {
+      function cacheHas(cache, key) {
+        return cache.has(key);
+      }
+      __name(cacheHas, "cacheHas");
+      module.exports = cacheHas;
+    }
+  });
+
+  // node_modules/lodash/_Set.js
+  var require_Set = __commonJS({
+    "node_modules/lodash/_Set.js"(exports, module) {
+      var getNative = require_getNative();
+      var root = require_root();
+      var Set2 = getNative(root, "Set");
+      module.exports = Set2;
+    }
+  });
+
+  // node_modules/lodash/noop.js
+  var require_noop = __commonJS({
+    "node_modules/lodash/noop.js"(exports, module) {
+      function noop() {
+      }
+      __name(noop, "noop");
+      module.exports = noop;
+    }
+  });
+
+  // node_modules/lodash/_setToArray.js
+  var require_setToArray = __commonJS({
+    "node_modules/lodash/_setToArray.js"(exports, module) {
+      function setToArray(set) {
+        var index = -1, result = Array(set.size);
+        set.forEach(function(value) {
+          result[++index] = value;
+        });
+        return result;
+      }
+      __name(setToArray, "setToArray");
+      module.exports = setToArray;
+    }
+  });
+
+  // node_modules/lodash/_createSet.js
+  var require_createSet = __commonJS({
+    "node_modules/lodash/_createSet.js"(exports, module) {
+      var Set2 = require_Set();
+      var noop = require_noop();
+      var setToArray = require_setToArray();
+      var INFINITY = 1 / 0;
+      var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY) ? noop : function(values) {
+        return new Set2(values);
+      };
+      module.exports = createSet;
+    }
+  });
+
+  // node_modules/lodash/_baseUniq.js
+  var require_baseUniq = __commonJS({
+    "node_modules/lodash/_baseUniq.js"(exports, module) {
+      var SetCache = require_SetCache();
+      var arrayIncludes = require_arrayIncludes();
+      var arrayIncludesWith = require_arrayIncludesWith();
+      var cacheHas = require_cacheHas();
+      var createSet = require_createSet();
+      var setToArray = require_setToArray();
+      var LARGE_ARRAY_SIZE = 200;
+      function baseUniq(array, iteratee, comparator) {
+        var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
+        if (comparator) {
+          isCommon = false;
+          includes = arrayIncludesWith;
+        } else if (length >= LARGE_ARRAY_SIZE) {
+          var set = iteratee ? null : createSet(array);
+          if (set) {
+            return setToArray(set);
+          }
+          isCommon = false;
+          includes = cacheHas;
+          seen = new SetCache();
+        } else {
+          seen = iteratee ? [] : result;
+        }
+        outer:
+          while (++index < length) {
+            var value = array[index], computed = iteratee ? iteratee(value) : value;
+            value = comparator || value !== 0 ? value : 0;
+            if (isCommon && computed === computed) {
+              var seenIndex = seen.length;
+              while (seenIndex--) {
+                if (seen[seenIndex] === computed) {
+                  continue outer;
+                }
+              }
+              if (iteratee) {
+                seen.push(computed);
+              }
+              result.push(value);
+            } else if (!includes(seen, computed, comparator)) {
+              if (seen !== result) {
+                seen.push(computed);
+              }
+              result.push(value);
+            }
+          }
+        return result;
+      }
+      __name(baseUniq, "baseUniq");
+      module.exports = baseUniq;
+    }
+  });
+
+  // node_modules/lodash/uniqWith.js
+  var require_uniqWith = __commonJS({
+    "node_modules/lodash/uniqWith.js"(exports, module) {
+      var baseUniq = require_baseUniq();
+      function uniqWith2(array, comparator) {
+        comparator = typeof comparator == "function" ? comparator : void 0;
+        return array && array.length ? baseUniq(array, void 0, comparator) : [];
+      }
+      __name(uniqWith2, "uniqWith");
+      module.exports = uniqWith2;
+    }
+  });
+
+  // src/lib/configs.ts
+  var validationEnabled = true;
+  function setGlobalValidationEnabled(enabled) {
+    validationEnabled = enabled;
+  }
+  __name(setGlobalValidationEnabled, "setGlobalValidationEnabled");
+  function getGlobalValidationEnabled() {
+    return validationEnabled;
+  }
+  __name(getGlobalValidationEnabled, "getGlobalValidationEnabled");
+
+  // src/lib/Result.ts
+  var Result = class {
+    constructor(success, value, error) {
+      this.success = success;
+      if (success) {
+        this.value = value;
+      } else {
+        this.error = error;
+      }
+    }
+    isOk() {
+      return this.success;
+    }
+    isErr() {
+      return !this.success;
+    }
+    unwrap() {
+      if (this.isOk())
+        return this.value;
+      throw this.error;
+    }
+    static ok(value) {
+      return new Result(true, value);
+    }
+    static err(error) {
+      return new Result(false, void 0, error);
+    }
+  };
+  __name(Result, "Result");
+
+  // src/validators/util/getValue.ts
+  function getValue(valueOrFn) {
+    return typeof valueOrFn === "function" ? valueOrFn() : valueOrFn;
+  }
+  __name(getValue, "getValue");
+
+  // src/constraints/ObjectConstrains.ts
+  var import_get = __toESM(require_get());
+
+  // node-modules-polyfills:util
+  var e;
+  var t;
+  var n;
+  var r = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : globalThis;
+  var o = e = {};
+  function i() {
+    throw new Error("setTimeout has not been defined");
+  }
+  __name(i, "i");
+  function u() {
+    throw new Error("clearTimeout has not been defined");
+  }
+  __name(u, "u");
+  function c(e3) {
+    if (t === setTimeout)
+      return setTimeout(e3, 0);
+    if ((t === i || !t) && setTimeout)
+      return t = setTimeout, setTimeout(e3, 0);
+    try {
+      return t(e3, 0);
+    } catch (n3) {
+      try {
+        return t.call(null, e3, 0);
+      } catch (n4) {
+        return t.call(this || r, e3, 0);
+      }
+    }
+  }
+  __name(c, "c");
+  !function() {
+    try {
+      t = "function" == typeof setTimeout ? setTimeout : i;
+    } catch (e3) {
+      t = i;
+    }
+    try {
+      n = "function" == typeof clearTimeout ? clearTimeout : u;
+    } catch (e3) {
+      n = u;
+    }
+  }();
+  var l;
+  var s = [];
+  var f = false;
+  var a = -1;
+  function h() {
+    f && l && (f = false, l.length ? s = l.concat(s) : a = -1, s.length && d());
+  }
+  __name(h, "h");
+  function d() {
+    if (!f) {
+      var e3 = c(h);
+      f = true;
+      for (var t3 = s.length; t3; ) {
+        for (l = s, s = []; ++a < t3; )
+          l && l[a].run();
+        a = -1, t3 = s.length;
+      }
+      l = null, f = false, function(e4) {
+        if (n === clearTimeout)
+          return clearTimeout(e4);
+        if ((n === u || !n) && clearTimeout)
+          return n = clearTimeout, clearTimeout(e4);
+        try {
+          n(e4);
+        } catch (t4) {
+          try {
+            return n.call(null, e4);
+          } catch (t5) {
+            return n.call(this || r, e4);
+          }
+        }
+      }(e3);
+    }
+  }
+  __name(d, "d");
+  function m(e3, t3) {
+    (this || r).fun = e3, (this || r).array = t3;
+  }
+  __name(m, "m");
+  function p() {
+  }
+  __name(p, "p");
+  o.nextTick = function(e3) {
+    var t3 = new Array(arguments.length - 1);
+    if (arguments.length > 1)
+      for (var n3 = 1; n3 < arguments.length; n3++)
+        t3[n3 - 1] = arguments[n3];
+    s.push(new m(e3, t3)), 1 !== s.length || f || c(d);
+  }, m.prototype.run = function() {
+    (this || r).fun.apply(null, (this || r).array);
+  }, o.title = "browser", o.browser = true, o.env = {}, o.argv = [], o.version = "", o.versions = {}, o.on = p, o.addListener = p, o.once = p, o.off = p, o.removeListener = p, o.removeAllListeners = p, o.emit = p, o.prependListener = p, o.prependOnceListener = p, o.listeners = function(e3) {
+    return [];
+  }, o.binding = function(e3) {
+    throw new Error("process.binding is not supported");
+  }, o.cwd = function() {
+    return "/";
+  }, o.chdir = function(e3) {
+    throw new Error("process.chdir is not supported");
+  }, o.umask = function() {
+    return 0;
+  };
+  var T = e;
+  T.addListener;
+  T.argv;
+  T.binding;
+  T.browser;
+  T.chdir;
+  T.cwd;
+  T.emit;
+  T.env;
+  T.listeners;
+  T.nextTick;
+  T.off;
+  T.on;
+  T.once;
+  T.prependListener;
+  T.prependOnceListener;
+  T.removeAllListeners;
+  T.removeListener;
+  T.title;
+  T.umask;
+  T.version;
+  T.versions;
+  var t2 = "function" == typeof Symbol && "symbol" == typeof Symbol.toStringTag;
+  var e2 = Object.prototype.toString;
+  var o2 = /* @__PURE__ */ __name(function(o3) {
+    return !(t2 && o3 && "object" == typeof o3 && Symbol.toStringTag in o3) && "[object Arguments]" === e2.call(o3);
+  }, "o2");
+  var n2 = /* @__PURE__ */ __name(function(t3) {
+    return !!o2(t3) || null !== t3 && "object" == typeof t3 && "number" == typeof t3.length && t3.length >= 0 && "[object Array]" !== e2.call(t3) && "[object Function]" === e2.call(t3.callee);
+  }, "n2");
+  var r2 = function() {
+    return o2(arguments);
+  }();
+  o2.isLegacyArguments = n2;
+  var l2 = r2 ? o2 : n2;
+  var t$1 = Object.prototype.toString;
+  var o$1 = Function.prototype.toString;
+  var n$1 = /^\s*(?:function)?\*/;
+  var e$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.toStringTag;
+  var r$1 = Object.getPrototypeOf;
+  var c2 = function() {
+    if (!e$1)
+      return false;
+    try {
+      return Function("return function*() {}")();
+    } catch (t3) {
+    }
+  }();
+  var u2 = c2 ? r$1(c2) : {};
+  var i2 = /* @__PURE__ */ __name(function(c3) {
+    return "function" == typeof c3 && (!!n$1.test(o$1.call(c3)) || (e$1 ? r$1(c3) === u2 : "[object GeneratorFunction]" === t$1.call(c3)));
+  }, "i2");
+  var t$2 = "function" == typeof Object.create ? function(t3, e3) {
+    e3 && (t3.super_ = e3, t3.prototype = Object.create(e3.prototype, { constructor: { value: t3, enumerable: false, writable: true, configurable: true } }));
+  } : function(t3, e3) {
+    if (e3) {
+      t3.super_ = e3;
+      var o3 = /* @__PURE__ */ __name(function() {
+      }, "o3");
+      o3.prototype = e3.prototype, t3.prototype = new o3(), t3.prototype.constructor = t3;
+    }
+  };
+  var i$1 = /* @__PURE__ */ __name(function(e3) {
+    return e3 && "object" == typeof e3 && "function" == typeof e3.copy && "function" == typeof e3.fill && "function" == typeof e3.readUInt8;
+  }, "i$1");
+  var o$2 = {};
+  var u$1 = i$1;
+  var f2 = l2;
+  var a2 = i2;
+  function c$1(e3) {
+    return e3.call.bind(e3);
+  }
+  __name(c$1, "c$1");
+  var s2 = "undefined" != typeof BigInt;
+  var p2 = "undefined" != typeof Symbol;
+  var y = p2 && void 0 !== Symbol.toStringTag;
+  var l$1 = "undefined" != typeof Uint8Array;
+  var d2 = "undefined" != typeof ArrayBuffer;
+  if (l$1 && y)
+    var g = Object.getPrototypeOf(Uint8Array.prototype), b = c$1(Object.getOwnPropertyDescriptor(g, Symbol.toStringTag).get);
+  var m2 = c$1(Object.prototype.toString);
+  var h2 = c$1(Number.prototype.valueOf);
+  var j = c$1(String.prototype.valueOf);
+  var A = c$1(Boolean.prototype.valueOf);
+  if (s2)
+    var w = c$1(BigInt.prototype.valueOf);
+  if (p2)
+    var v = c$1(Symbol.prototype.valueOf);
+  function O(e3, t3) {
+    if ("object" != typeof e3)
+      return false;
+    try {
+      return t3(e3), true;
+    } catch (e4) {
+      return false;
+    }
+  }
+  __name(O, "O");
+  function S(e3) {
+    return l$1 && y ? void 0 !== b(e3) : B(e3) || k(e3) || E(e3) || D(e3) || U(e3) || P(e3) || x(e3) || I(e3) || M(e3) || z(e3) || F(e3);
+  }
+  __name(S, "S");
+  function B(e3) {
+    return l$1 && y ? "Uint8Array" === b(e3) : "[object Uint8Array]" === m2(e3) || u$1(e3) && void 0 !== e3.buffer;
+  }
+  __name(B, "B");
+  function k(e3) {
+    return l$1 && y ? "Uint8ClampedArray" === b(e3) : "[object Uint8ClampedArray]" === m2(e3);
+  }
+  __name(k, "k");
+  function E(e3) {
+    return l$1 && y ? "Uint16Array" === b(e3) : "[object Uint16Array]" === m2(e3);
+  }
+  __name(E, "E");
+  function D(e3) {
+    return l$1 && y ? "Uint32Array" === b(e3) : "[object Uint32Array]" === m2(e3);
+  }
+  __name(D, "D");
+  function U(e3) {
+    return l$1 && y ? "Int8Array" === b(e3) : "[object Int8Array]" === m2(e3);
+  }
+  __name(U, "U");
+  function P(e3) {
+    return l$1 && y ? "Int16Array" === b(e3) : "[object Int16Array]" === m2(e3);
+  }
+  __name(P, "P");
+  function x(e3) {
+    return l$1 && y ? "Int32Array" === b(e3) : "[object Int32Array]" === m2(e3);
+  }
+  __name(x, "x");
+  function I(e3) {
+    return l$1 && y ? "Float32Array" === b(e3) : "[object Float32Array]" === m2(e3);
+  }
+  __name(I, "I");
+  function M(e3) {
+    return l$1 && y ? "Float64Array" === b(e3) : "[object Float64Array]" === m2(e3);
+  }
+  __name(M, "M");
+  function z(e3) {
+    return l$1 && y ? "BigInt64Array" === b(e3) : "[object BigInt64Array]" === m2(e3);
+  }
+  __name(z, "z");
+  function F(e3) {
+    return l$1 && y ? "BigUint64Array" === b(e3) : "[object BigUint64Array]" === m2(e3);
+  }
+  __name(F, "F");
+  function T2(e3) {
+    return "[object Map]" === m2(e3);
+  }
+  __name(T2, "T2");
+  function N(e3) {
+    return "[object Set]" === m2(e3);
+  }
+  __name(N, "N");
+  function W(e3) {
+    return "[object WeakMap]" === m2(e3);
+  }
+  __name(W, "W");
+  function $(e3) {
+    return "[object WeakSet]" === m2(e3);
+  }
+  __name($, "$");
+  function C(e3) {
+    return "[object ArrayBuffer]" === m2(e3);
+  }
+  __name(C, "C");
+  function V(e3) {
+    return "undefined" != typeof ArrayBuffer && (C.working ? C(e3) : e3 instanceof ArrayBuffer);
+  }
+  __name(V, "V");
+  function G(e3) {
+    return "[object DataView]" === m2(e3);
+  }
+  __name(G, "G");
+  function R(e3) {
+    return "undefined" != typeof DataView && (G.working ? G(e3) : e3 instanceof DataView);
+  }
+  __name(R, "R");
+  function J(e3) {
+    return "[object SharedArrayBuffer]" === m2(e3);
+  }
+  __name(J, "J");
+  function _(e3) {
+    return "undefined" != typeof SharedArrayBuffer && (J.working ? J(e3) : e3 instanceof SharedArrayBuffer);
+  }
+  __name(_, "_");
+  function H(e3) {
+    return O(e3, h2);
+  }
+  __name(H, "H");
+  function Z(e3) {
+    return O(e3, j);
+  }
+  __name(Z, "Z");
+  function q(e3) {
+    return O(e3, A);
+  }
+  __name(q, "q");
+  function K(e3) {
+    return s2 && O(e3, w);
+  }
+  __name(K, "K");
+  function L(e3) {
+    return p2 && O(e3, v);
+  }
+  __name(L, "L");
+  o$2.isArgumentsObject = f2, o$2.isGeneratorFunction = a2, o$2.isPromise = function(e3) {
+    return "undefined" != typeof Promise && e3 instanceof Promise || null !== e3 && "object" == typeof e3 && "function" == typeof e3.then && "function" == typeof e3.catch;
+  }, o$2.isArrayBufferView = function(e3) {
+    return d2 && ArrayBuffer.isView ? ArrayBuffer.isView(e3) : S(e3) || R(e3);
+  }, o$2.isTypedArray = S, o$2.isUint8Array = B, o$2.isUint8ClampedArray = k, o$2.isUint16Array = E, o$2.isUint32Array = D, o$2.isInt8Array = U, o$2.isInt16Array = P, o$2.isInt32Array = x, o$2.isFloat32Array = I, o$2.isFloat64Array = M, o$2.isBigInt64Array = z, o$2.isBigUint64Array = F, T2.working = "undefined" != typeof Map && T2(/* @__PURE__ */ new Map()), o$2.isMap = function(e3) {
+    return "undefined" != typeof Map && (T2.working ? T2(e3) : e3 instanceof Map);
+  }, N.working = "undefined" != typeof Set && N(/* @__PURE__ */ new Set()), o$2.isSet = function(e3) {
+    return "undefined" != typeof Set && (N.working ? N(e3) : e3 instanceof Set);
+  }, W.working = "undefined" != typeof WeakMap && W(/* @__PURE__ */ new WeakMap()), o$2.isWeakMap = function(e3) {
+    return "undefined" != typeof WeakMap && (W.working ? W(e3) : e3 instanceof WeakMap);
+  }, $.working = "undefined" != typeof WeakSet && $(/* @__PURE__ */ new WeakSet()), o$2.isWeakSet = function(e3) {
+    return $(e3);
+  }, C.working = "undefined" != typeof ArrayBuffer && C(new ArrayBuffer()), o$2.isArrayBuffer = V, G.working = "undefined" != typeof ArrayBuffer && "undefined" != typeof DataView && G(new DataView(new ArrayBuffer(1), 0, 1)), o$2.isDataView = R, J.working = "undefined" != typeof SharedArrayBuffer && J(new SharedArrayBuffer()), o$2.isSharedArrayBuffer = _, o$2.isAsyncFunction = function(e3) {
+    return "[object AsyncFunction]" === m2(e3);
+  }, o$2.isMapIterator = function(e3) {
+    return "[object Map Iterator]" === m2(e3);
+  }, o$2.isSetIterator = function(e3) {
+    return "[object Set Iterator]" === m2(e3);
+  }, o$2.isGeneratorObject = function(e3) {
+    return "[object Generator]" === m2(e3);
+  }, o$2.isWebAssemblyCompiledModule = function(e3) {
+    return "[object WebAssembly.Module]" === m2(e3);
+  }, o$2.isNumberObject = H, o$2.isStringObject = Z, o$2.isBooleanObject = q, o$2.isBigIntObject = K, o$2.isSymbolObject = L, o$2.isBoxedPrimitive = function(e3) {
+    return H(e3) || Z(e3) || q(e3) || K(e3) || L(e3);
+  }, o$2.isAnyArrayBuffer = function(e3) {
+    return l$1 && (V(e3) || _(e3));
+  }, ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(e3) {
+    Object.defineProperty(o$2, e3, { enumerable: false, value: function() {
+      throw new Error(e3 + " is not supported in userland");
+    } });
+  });
+  var Q = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : globalThis;
+  var X = {};
+  var Y = T;
+  var ee = Object.getOwnPropertyDescriptors || function(e3) {
+    for (var t3 = Object.keys(e3), r3 = {}, n3 = 0; n3 < t3.length; n3++)
+      r3[t3[n3]] = Object.getOwnPropertyDescriptor(e3, t3[n3]);
+    return r3;
+  };
+  var te = /%[sdj%]/g;
+  X.format = function(e3) {
+    if (!ge(e3)) {
+      for (var t3 = [], r3 = 0; r3 < arguments.length; r3++)
+        t3.push(oe(arguments[r3]));
+      return t3.join(" ");
+    }
+    r3 = 1;
+    for (var n3 = arguments, i3 = n3.length, o3 = String(e3).replace(te, function(e4) {
+      if ("%%" === e4)
+        return "%";
+      if (r3 >= i3)
+        return e4;
+      switch (e4) {
+        case "%s":
+          return String(n3[r3++]);
+        case "%d":
+          return Number(n3[r3++]);
+        case "%j":
+          try {
+            return JSON.stringify(n3[r3++]);
+          } catch (e5) {
+            return "[Circular]";
+          }
+        default:
+          return e4;
+      }
+    }), u3 = n3[r3]; r3 < i3; u3 = n3[++r3])
+      le(u3) || !he(u3) ? o3 += " " + u3 : o3 += " " + oe(u3);
+    return o3;
+  }, X.deprecate = function(e3, t3) {
+    if (void 0 !== Y && true === Y.noDeprecation)
+      return e3;
+    if (void 0 === Y)
+      return function() {
+        return X.deprecate(e3, t3).apply(this || Q, arguments);
+      };
+    var r3 = false;
+    return function() {
+      if (!r3) {
+        if (Y.throwDeprecation)
+          throw new Error(t3);
+        Y.traceDeprecation ? console.trace(t3) : console.error(t3), r3 = true;
+      }
+      return e3.apply(this || Q, arguments);
+    };
+  };
+  var re = {};
+  var ne = /^$/;
+  if (Y.env.NODE_DEBUG) {
+    ie = Y.env.NODE_DEBUG;
+    ie = ie.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase(), ne = new RegExp("^" + ie + "$", "i");
+  }
+  var ie;
+  function oe(e3, t3) {
+    var r3 = { seen: [], stylize: fe };
+    return arguments.length >= 3 && (r3.depth = arguments[2]), arguments.length >= 4 && (r3.colors = arguments[3]), ye(t3) ? r3.showHidden = t3 : t3 && X._extend(r3, t3), be(r3.showHidden) && (r3.showHidden = false), be(r3.depth) && (r3.depth = 2), be(r3.colors) && (r3.colors = false), be(r3.customInspect) && (r3.customInspect = true), r3.colors && (r3.stylize = ue), ae(r3, e3, r3.depth);
+  }
+  __name(oe, "oe");
+  function ue(e3, t3) {
+    var r3 = oe.styles[t3];
+    return r3 ? "\x1B[" + oe.colors[r3][0] + "m" + e3 + "\x1B[" + oe.colors[r3][1] + "m" : e3;
+  }
+  __name(ue, "ue");
+  function fe(e3, t3) {
+    return e3;
+  }
+  __name(fe, "fe");
+  function ae(e3, t3, r3) {
+    if (e3.customInspect && t3 && we(t3.inspect) && t3.inspect !== X.inspect && (!t3.constructor || t3.constructor.prototype !== t3)) {
+      var n3 = t3.inspect(r3, e3);
+      return ge(n3) || (n3 = ae(e3, n3, r3)), n3;
+    }
+    var i3 = function(e4, t4) {
+      if (be(t4))
+        return e4.stylize("undefined", "undefined");
+      if (ge(t4)) {
+        var r4 = "'" + JSON.stringify(t4).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+        return e4.stylize(r4, "string");
+      }
+      if (de(t4))
+        return e4.stylize("" + t4, "number");
+      if (ye(t4))
+        return e4.stylize("" + t4, "boolean");
+      if (le(t4))
+        return e4.stylize("null", "null");
+    }(e3, t3);
+    if (i3)
+      return i3;
+    var o3 = Object.keys(t3), u3 = function(e4) {
+      var t4 = {};
+      return e4.forEach(function(e5, r4) {
+        t4[e5] = true;
+      }), t4;
+    }(o3);
+    if (e3.showHidden && (o3 = Object.getOwnPropertyNames(t3)), Ae(t3) && (o3.indexOf("message") >= 0 || o3.indexOf("description") >= 0))
+      return ce(t3);
+    if (0 === o3.length) {
+      if (we(t3)) {
+        var f3 = t3.name ? ": " + t3.name : "";
+        return e3.stylize("[Function" + f3 + "]", "special");
+      }
+      if (me(t3))
+        return e3.stylize(RegExp.prototype.toString.call(t3), "regexp");
+      if (je(t3))
+        return e3.stylize(Date.prototype.toString.call(t3), "date");
+      if (Ae(t3))
+        return ce(t3);
+    }
+    var a3, c3 = "", s32 = false, p3 = ["{", "}"];
+    (pe(t3) && (s32 = true, p3 = ["[", "]"]), we(t3)) && (c3 = " [Function" + (t3.name ? ": " + t3.name : "") + "]");
+    return me(t3) && (c3 = " " + RegExp.prototype.toString.call(t3)), je(t3) && (c3 = " " + Date.prototype.toUTCString.call(t3)), Ae(t3) && (c3 = " " + ce(t3)), 0 !== o3.length || s32 && 0 != t3.length ? r3 < 0 ? me(t3) ? e3.stylize(RegExp.prototype.toString.call(t3), "regexp") : e3.stylize("[Object]", "special") : (e3.seen.push(t3), a3 = s32 ? function(e4, t4, r4, n4, i4) {
+      for (var o4 = [], u4 = 0, f4 = t4.length; u4 < f4; ++u4)
+        ke(t4, String(u4)) ? o4.push(se(e4, t4, r4, n4, String(u4), true)) : o4.push("");
+      return i4.forEach(function(i5) {
+        i5.match(/^\d+$/) || o4.push(se(e4, t4, r4, n4, i5, true));
+      }), o4;
+    }(e3, t3, r3, u3, o3) : o3.map(function(n4) {
+      return se(e3, t3, r3, u3, n4, s32);
+    }), e3.seen.pop(), function(e4, t4, r4) {
+      var n4 = 0;
+      if (e4.reduce(function(e5, t5) {
+        return n4++, t5.indexOf("\n") >= 0 && n4++, e5 + t5.replace(/\u001b\[\d\d?m/g, "").length + 1;
+      }, 0) > 60)
+        return r4[0] + ("" === t4 ? "" : t4 + "\n ") + " " + e4.join(",\n  ") + " " + r4[1];
+      return r4[0] + t4 + " " + e4.join(", ") + " " + r4[1];
+    }(a3, c3, p3)) : p3[0] + c3 + p3[1];
+  }
+  __name(ae, "ae");
+  function ce(e3) {
+    return "[" + Error.prototype.toString.call(e3) + "]";
+  }
+  __name(ce, "ce");
+  function se(e3, t3, r3, n3, i3, o3) {
+    var u3, f3, a3;
+    if ((a3 = Object.getOwnPropertyDescriptor(t3, i3) || { value: t3[i3] }).get ? f3 = a3.set ? e3.stylize("[Getter/Setter]", "special") : e3.stylize("[Getter]", "special") : a3.set && (f3 = e3.stylize("[Setter]", "special")), ke(n3, i3) || (u3 = "[" + i3 + "]"), f3 || (e3.seen.indexOf(a3.value) < 0 ? (f3 = le(r3) ? ae(e3, a3.value, null) : ae(e3, a3.value, r3 - 1)).indexOf("\n") > -1 && (f3 = o3 ? f3.split("\n").map(function(e4) {
+      return "  " + e4;
+    }).join("\n").substr(2) : "\n" + f3.split("\n").map(function(e4) {
+      return "   " + e4;
+    }).join("\n")) : f3 = e3.stylize("[Circular]", "special")), be(u3)) {
+      if (o3 && i3.match(/^\d+$/))
+        return f3;
+      (u3 = JSON.stringify("" + i3)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (u3 = u3.substr(1, u3.length - 2), u3 = e3.stylize(u3, "name")) : (u3 = u3.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), u3 = e3.stylize(u3, "string"));
+    }
+    return u3 + ": " + f3;
+  }
+  __name(se, "se");
+  function pe(e3) {
+    return Array.isArray(e3);
+  }
+  __name(pe, "pe");
+  function ye(e3) {
+    return "boolean" == typeof e3;
+  }
+  __name(ye, "ye");
+  function le(e3) {
+    return null === e3;
+  }
+  __name(le, "le");
+  function de(e3) {
+    return "number" == typeof e3;
+  }
+  __name(de, "de");
+  function ge(e3) {
+    return "string" == typeof e3;
+  }
+  __name(ge, "ge");
+  function be(e3) {
+    return void 0 === e3;
+  }
+  __name(be, "be");
+  function me(e3) {
+    return he(e3) && "[object RegExp]" === ve(e3);
+  }
+  __name(me, "me");
+  function he(e3) {
+    return "object" == typeof e3 && null !== e3;
+  }
+  __name(he, "he");
+  function je(e3) {
+    return he(e3) && "[object Date]" === ve(e3);
+  }
+  __name(je, "je");
+  function Ae(e3) {
+    return he(e3) && ("[object Error]" === ve(e3) || e3 instanceof Error);
+  }
+  __name(Ae, "Ae");
+  function we(e3) {
+    return "function" == typeof e3;
+  }
+  __name(we, "we");
+  function ve(e3) {
+    return Object.prototype.toString.call(e3);
+  }
+  __name(ve, "ve");
+  function Oe(e3) {
+    return e3 < 10 ? "0" + e3.toString(10) : e3.toString(10);
+  }
+  __name(Oe, "Oe");
+  X.debuglog = function(e3) {
+    if (e3 = e3.toUpperCase(), !re[e3])
+      if (ne.test(e3)) {
+        var t3 = Y.pid;
+        re[e3] = function() {
+          var r3 = X.format.apply(X, arguments);
+          console.error("%s %d: %s", e3, t3, r3);
+        };
+      } else
+        re[e3] = function() {
+        };
+    return re[e3];
+  }, X.inspect = oe, oe.colors = { bold: [1, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], white: [37, 39], grey: [90, 39], black: [30, 39], blue: [34, 39], cyan: [36, 39], green: [32, 39], magenta: [35, 39], red: [31, 39], yellow: [33, 39] }, oe.styles = { special: "cyan", number: "yellow", boolean: "yellow", undefined: "grey", null: "bold", string: "green", date: "magenta", regexp: "red" }, X.types = o$2, X.isArray = pe, X.isBoolean = ye, X.isNull = le, X.isNullOrUndefined = function(e3) {
+    return null == e3;
+  }, X.isNumber = de, X.isString = ge, X.isSymbol = function(e3) {
+    return "symbol" == typeof e3;
+  }, X.isUndefined = be, X.isRegExp = me, X.types.isRegExp = me, X.isObject = he, X.isDate = je, X.types.isDate = je, X.isError = Ae, X.types.isNativeError = Ae, X.isFunction = we, X.isPrimitive = function(e3) {
+    return null === e3 || "boolean" == typeof e3 || "number" == typeof e3 || "string" == typeof e3 || "symbol" == typeof e3 || void 0 === e3;
+  }, X.isBuffer = i$1;
+  var Se = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  function Be() {
+    var e3 = /* @__PURE__ */ new Date(), t3 = [Oe(e3.getHours()), Oe(e3.getMinutes()), Oe(e3.getSeconds())].join(":");
+    return [e3.getDate(), Se[e3.getMonth()], t3].join(" ");
+  }
+  __name(Be, "Be");
+  function ke(e3, t3) {
+    return Object.prototype.hasOwnProperty.call(e3, t3);
+  }
+  __name(ke, "ke");
+  X.log = function() {
+    console.log("%s - %s", Be(), X.format.apply(X, arguments));
+  }, X.inherits = t$2, X._extend = function(e3, t3) {
+    if (!t3 || !he(t3))
+      return e3;
+    for (var r3 = Object.keys(t3), n3 = r3.length; n3--; )
+      e3[r3[n3]] = t3[r3[n3]];
+    return e3;
+  };
+  var Ee = "undefined" != typeof Symbol ? Symbol("util.promisify.custom") : void 0;
+  function De(e3, t3) {
+    if (!e3) {
+      var r3 = new Error("Promise was rejected with a falsy value");
+      r3.reason = e3, e3 = r3;
+    }
+    return t3(e3);
+  }
+  __name(De, "De");
+  X.promisify = function(e3) {
+    if ("function" != typeof e3)
+      throw new TypeError('The "original" argument must be of type Function');
+    if (Ee && e3[Ee]) {
+      var t3;
+      if ("function" != typeof (t3 = e3[Ee]))
+        throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+      return Object.defineProperty(t3, Ee, { value: t3, enumerable: false, writable: false, configurable: true }), t3;
+    }
+    function t3() {
+      for (var t4, r3, n3 = new Promise(function(e4, n4) {
+        t4 = e4, r3 = n4;
+      }), i3 = [], o3 = 0; o3 < arguments.length; o3++)
+        i3.push(arguments[o3]);
+      i3.push(function(e4, n4) {
+        e4 ? r3(e4) : t4(n4);
+      });
+      try {
+        e3.apply(this || Q, i3);
+      } catch (e4) {
+        r3(e4);
+      }
+      return n3;
+    }
+    __name(t3, "t3");
+    return Object.setPrototypeOf(t3, Object.getPrototypeOf(e3)), Ee && Object.defineProperty(t3, Ee, { value: t3, enumerable: false, writable: false, configurable: true }), Object.defineProperties(t3, ee(e3));
+  }, X.promisify.custom = Ee, X.callbackify = function(e3) {
+    if ("function" != typeof e3)
+      throw new TypeError('The "original" argument must be of type Function');
+    function t3() {
+      for (var t4 = [], r3 = 0; r3 < arguments.length; r3++)
+        t4.push(arguments[r3]);
+      var n3 = t4.pop();
+      if ("function" != typeof n3)
+        throw new TypeError("The last argument must be of type Function");
+      var i3 = this || Q, o3 = /* @__PURE__ */ __name(function() {
+        return n3.apply(i3, arguments);
+      }, "o3");
+      e3.apply(this || Q, t4).then(function(e4) {
+        Y.nextTick(o3.bind(null, null, e4));
+      }, function(e4) {
+        Y.nextTick(De.bind(null, e4, o3));
+      });
+    }
+    __name(t3, "t3");
+    return Object.setPrototypeOf(t3, Object.getPrototypeOf(e3)), Object.defineProperties(t3, ee(e3)), t3;
+  };
+  X._extend;
+  X.callbackify;
+  X.debuglog;
+  X.deprecate;
+  X.format;
+  X.inherits;
+  X.inspect;
+  X.isArray;
+  X.isBoolean;
+  X.isBuffer;
+  X.isDate;
+  X.isError;
+  X.isFunction;
+  X.isNull;
+  X.isNullOrUndefined;
+  X.isNumber;
+  X.isObject;
+  X.isPrimitive;
+  X.isRegExp;
+  X.isString;
+  X.isSymbol;
+  X.isUndefined;
+  X.log;
+  X.promisify;
+  X._extend;
+  X.callbackify;
+  X.debuglog;
+  X.deprecate;
+  X.format;
+  X.inherits;
+  X.inspect;
+  X.isArray;
+  X.isBoolean;
+  X.isBuffer;
+  X.isDate;
+  X.isError;
+  X.isFunction;
+  X.isNull;
+  X.isNullOrUndefined;
+  X.isNumber;
+  X.isObject;
+  X.isPrimitive;
+  X.isRegExp;
+  X.isString;
+  X.isSymbol;
+  X.isUndefined;
+  X.log;
+  X.promisify;
+  X.types;
+  X._extend;
+  X.callbackify;
+  X.debuglog;
+  X.deprecate;
+  X.format;
+  X.inherits;
+  var inspect2 = X.inspect;
+  X.isArray;
+  X.isBoolean;
+  X.isBuffer;
+  X.isDate;
+  X.isError;
+  X.isFunction;
+  X.isNull;
+  X.isNullOrUndefined;
+  X.isNumber;
+  X.isObject;
+  X.isPrimitive;
+  X.isRegExp;
+  X.isString;
+  X.isSymbol;
+  X.isUndefined;
+  X.log;
+  X.promisify;
+  X.types;
+  X.TextEncoder = globalThis.TextEncoder;
+  X.TextDecoder = globalThis.TextDecoder;
+
+  // src/lib/errors/BaseError.ts
+  var customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+  var customInspectSymbolStackLess = Symbol.for("nodejs.util.inspect.custom.stack-less");
+  var BaseError = class extends Error {
+    [customInspectSymbol](depth, options) {
+      return `${this[customInspectSymbolStackLess](depth, options)}
+${this.stack.slice(this.stack.indexOf("\n"))}`;
+    }
+  };
+  __name(BaseError, "BaseError");
+
+  // src/lib/errors/BaseConstraintError.ts
+  var BaseConstraintError = class extends BaseError {
+    constructor(constraint, message, given) {
+      super(message);
+      this.constraint = constraint;
+      this.given = given;
+    }
+  };
+  __name(BaseConstraintError, "BaseConstraintError");
+
+  // src/lib/errors/ExpectedConstraintError.ts
+  var ExpectedConstraintError = class extends BaseConstraintError {
+    constructor(constraint, message, given, expected) {
+      super(constraint, message, given);
+      this.expected = expected;
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        constraint: this.constraint,
+        given: this.given,
+        expected: this.expected
+      };
+    }
+    [customInspectSymbolStackLess](depth, options) {
+      const constraint = options.stylize(this.constraint, "string");
+      if (depth < 0) {
+        return options.stylize(`[ExpectedConstraintError: ${constraint}]`, "special");
+      }
+      const newOptions = { ...options, depth: options.depth === null ? null : options.depth - 1 };
+      const padding = `
+  ${options.stylize("|", "undefined")} `;
+      const given = inspect2(this.given, newOptions).replace(/\n/g, padding);
+      const header = `${options.stylize("ExpectedConstraintError", "special")} > ${constraint}`;
+      const message = options.stylize(this.message, "regexp");
+      const expectedBlock = `
+  ${options.stylize("Expected: ", "string")}${options.stylize(this.expected, "boolean")}`;
+      const givenBlock = `
+  ${options.stylize("Received:", "regexp")}${padding}${given}`;
+      return `${header}
+  ${message}
+${expectedBlock}
+${givenBlock}`;
+    }
+  };
+  __name(ExpectedConstraintError, "ExpectedConstraintError");
+
+  // src/constraints/ObjectConstrains.ts
+  function whenConstraint(key, options, validator) {
+    return {
+      run(input, parent) {
+        if (!parent) {
+          return Result.err(new ExpectedConstraintError("s.object(T.when)", "Validator has no parent", parent, "Validator to have a parent"));
+        }
+        const isKeyArray = Array.isArray(key);
+        const value = isKeyArray ? key.map((k2) => (0, import_get.default)(parent, k2)) : (0, import_get.default)(parent, key);
+        const predicate = resolveBooleanIs(options, value, isKeyArray) ? options.then : options.otherwise;
+        if (predicate) {
+          return predicate(validator).run(input);
+        }
+        return Result.ok(input);
+      }
+    };
+  }
+  __name(whenConstraint, "whenConstraint");
+  function resolveBooleanIs(options, value, isKeyArray) {
+    if (options.is === void 0) {
+      return isKeyArray ? !value.some((val) => !val) : Boolean(value);
+    }
+    if (typeof options.is === "function") {
+      return options.is(value);
+    }
+    return value === options.is;
+  }
+  __name(resolveBooleanIs, "resolveBooleanIs");
+
+  // src/validators/BaseValidator.ts
+  var BaseValidator = class {
+    constructor(constraints = []) {
+      this.constraints = [];
+      this.isValidationEnabled = null;
+      this.constraints = constraints;
+    }
+    setParent(parent) {
+      this.parent = parent;
+      return this;
+    }
+    get optional() {
+      return new UnionValidator([new LiteralValidator(void 0), this.clone()]);
+    }
+    get nullable() {
+      return new UnionValidator([new LiteralValidator(null), this.clone()]);
+    }
+    get nullish() {
+      return new UnionValidator([new NullishValidator(), this.clone()]);
+    }
+    get array() {
+      return new ArrayValidator(this.clone());
+    }
+    get set() {
+      return new SetValidator(this.clone());
+    }
+    or(...predicates) {
+      return new UnionValidator([this.clone(), ...predicates]);
+    }
+    transform(cb) {
+      return this.addConstraint({ run: (input) => Result.ok(cb(input)) });
+    }
+    reshape(cb) {
+      return this.addConstraint({ run: cb });
+    }
+    default(value) {
+      return new DefaultValidator(this.clone(), value);
+    }
+    when(key, options) {
+      return this.addConstraint(whenConstraint(key, options, this));
+    }
+    describe(description) {
+      const clone = this.clone();
+      clone.description = description;
+      return clone;
+    }
+    run(value) {
+      let result = this.handle(value);
+      if (result.isErr())
+        return result;
+      for (const constraint of this.constraints) {
+        result = constraint.run(result.value, this.parent);
+        if (result.isErr())
+          break;
+      }
+      return result;
+    }
+    parse(value) {
+      if (!this.shouldRunConstraints) {
+        return this.handle(value).unwrap();
+      }
+      return this.constraints.reduce((v2, constraint) => constraint.run(v2).unwrap(), this.handle(value).unwrap());
+    }
+    is(value) {
+      return this.run(value).isOk();
+    }
+    /**
+     * Sets if the validator should also run constraints or just do basic checks.
+     * @param isValidationEnabled Whether this validator should be enabled or disabled. You can pass boolean or a function returning boolean which will be called just before parsing.
+     * Set to `null` to go off of the global configuration.
+     */
+    setValidationEnabled(isValidationEnabled) {
+      const clone = this.clone();
+      clone.isValidationEnabled = isValidationEnabled;
+      return clone;
+    }
+    getValidationEnabled() {
+      return getValue(this.isValidationEnabled);
+    }
+    get shouldRunConstraints() {
+      return getValue(this.isValidationEnabled) ?? getGlobalValidationEnabled();
+    }
+    clone() {
+      const clone = Reflect.construct(this.constructor, [this.constraints]);
+      clone.isValidationEnabled = this.isValidationEnabled;
+      return clone;
+    }
+    addConstraint(constraint) {
+      const clone = this.clone();
+      clone.constraints = clone.constraints.concat(constraint);
+      return clone;
+    }
+  };
+  __name(BaseValidator, "BaseValidator");
+
+  // src/constraints/util/isUnique.ts
+  var import_es6 = __toESM(require_es6());
+  var import_uniqWith = __toESM(require_uniqWith());
+  function isUnique(input) {
+    if (input.length < 2)
+      return true;
+    const uniqueArray2 = (0, import_uniqWith.default)(input, import_es6.default);
+    return uniqueArray2.length === input.length;
+  }
+  __name(isUnique, "isUnique");
+
+  // src/constraints/util/operators.ts
+  function lessThan(a3, b2) {
+    return a3 < b2;
+  }
+  __name(lessThan, "lessThan");
+  function lessThanOrEqual(a3, b2) {
+    return a3 <= b2;
+  }
+  __name(lessThanOrEqual, "lessThanOrEqual");
+  function greaterThan(a3, b2) {
+    return a3 > b2;
+  }
+  __name(greaterThan, "greaterThan");
+  function greaterThanOrEqual(a3, b2) {
+    return a3 >= b2;
+  }
+  __name(greaterThanOrEqual, "greaterThanOrEqual");
+  function equal(a3, b2) {
+    return a3 === b2;
+  }
+  __name(equal, "equal");
+  function notEqual(a3, b2) {
+    return a3 !== b2;
+  }
+  __name(notEqual, "notEqual");
+
+  // src/constraints/ArrayConstraints.ts
+  function arrayLengthComparator(comparator, name, expected, length) {
+    return {
+      run(input) {
+        return comparator(input.length, length) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, "Invalid Array length", input, expected));
+      }
+    };
+  }
+  __name(arrayLengthComparator, "arrayLengthComparator");
+  function arrayLengthLessThan(value) {
+    const expected = `expected.length < ${value}`;
+    return arrayLengthComparator(lessThan, "s.array(T).lengthLessThan", expected, value);
+  }
+  __name(arrayLengthLessThan, "arrayLengthLessThan");
+  function arrayLengthLessThanOrEqual(value) {
+    const expected = `expected.length <= ${value}`;
+    return arrayLengthComparator(lessThanOrEqual, "s.array(T).lengthLessThanOrEqual", expected, value);
+  }
+  __name(arrayLengthLessThanOrEqual, "arrayLengthLessThanOrEqual");
+  function arrayLengthGreaterThan(value) {
+    const expected = `expected.length > ${value}`;
+    return arrayLengthComparator(greaterThan, "s.array(T).lengthGreaterThan", expected, value);
+  }
+  __name(arrayLengthGreaterThan, "arrayLengthGreaterThan");
+  function arrayLengthGreaterThanOrEqual(value) {
+    const expected = `expected.length >= ${value}`;
+    return arrayLengthComparator(greaterThanOrEqual, "s.array(T).lengthGreaterThanOrEqual", expected, value);
+  }
+  __name(arrayLengthGreaterThanOrEqual, "arrayLengthGreaterThanOrEqual");
+  function arrayLengthEqual(value) {
+    const expected = `expected.length === ${value}`;
+    return arrayLengthComparator(equal, "s.array(T).lengthEqual", expected, value);
+  }
+  __name(arrayLengthEqual, "arrayLengthEqual");
+  function arrayLengthNotEqual(value) {
+    const expected = `expected.length !== ${value}`;
+    return arrayLengthComparator(notEqual, "s.array(T).lengthNotEqual", expected, value);
+  }
+  __name(arrayLengthNotEqual, "arrayLengthNotEqual");
+  function arrayLengthRange(start, endBefore) {
+    const expected = `expected.length >= ${start} && expected.length < ${endBefore}`;
+    return {
+      run(input) {
+        return input.length >= start && input.length < endBefore ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.array(T).lengthRange", "Invalid Array length", input, expected));
+      }
+    };
+  }
+  __name(arrayLengthRange, "arrayLengthRange");
+  function arrayLengthRangeInclusive(start, end) {
+    const expected = `expected.length >= ${start} && expected.length <= ${end}`;
+    return {
+      run(input) {
+        return input.length >= start && input.length <= end ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.array(T).lengthRangeInclusive", "Invalid Array length", input, expected));
+      }
+    };
+  }
+  __name(arrayLengthRangeInclusive, "arrayLengthRangeInclusive");
+  function arrayLengthRangeExclusive(startAfter, endBefore) {
+    const expected = `expected.length > ${startAfter} && expected.length < ${endBefore}`;
+    return {
+      run(input) {
+        return input.length > startAfter && input.length < endBefore ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.array(T).lengthRangeExclusive", "Invalid Array length", input, expected));
+      }
+    };
+  }
+  __name(arrayLengthRangeExclusive, "arrayLengthRangeExclusive");
+  var uniqueArray = {
+    run(input) {
+      return isUnique(input) ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.array(T).unique", "Array values are not unique", input, "Expected all values to be unique"));
+    }
+  };
+
+  // src/lib/errors/CombinedPropertyError.ts
+  var CombinedPropertyError = class extends BaseError {
+    constructor(errors) {
+      super("Received one or more errors");
+      this.errors = errors;
+    }
+    [customInspectSymbolStackLess](depth, options) {
+      if (depth < 0) {
+        return options.stylize("[CombinedPropertyError]", "special");
+      }
+      const newOptions = { ...options, depth: options.depth === null ? null : options.depth - 1, compact: true };
+      const padding = `
+  ${options.stylize("|", "undefined")} `;
+      const header = `${options.stylize("CombinedPropertyError", "special")} (${options.stylize(this.errors.length.toString(), "number")})`;
+      const message = options.stylize(this.message, "regexp");
+      const errors = this.errors.map(([key, error]) => {
+        const property = CombinedPropertyError.formatProperty(key, options);
+        const body = error[customInspectSymbolStackLess](depth - 1, newOptions).replace(/\n/g, padding);
+        return `  input${property}${padding}${body}`;
+      }).join("\n\n");
+      return `${header}
+  ${message}
+
+${errors}`;
+    }
+    static formatProperty(key, options) {
+      if (typeof key === "string")
+        return options.stylize(`.${key}`, "symbol");
+      if (typeof key === "number")
+        return `[${options.stylize(key.toString(), "number")}]`;
+      return `[${options.stylize("Symbol", "symbol")}(${key.description})]`;
+    }
+  };
+  __name(CombinedPropertyError, "CombinedPropertyError");
+
+  // src/lib/errors/ValidationError.ts
+  var ValidationError = class extends BaseError {
+    constructor(validator, message, given) {
+      super(message);
+      this.validator = validator;
+      this.given = given;
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        validator: this.validator,
+        given: this.given
+      };
+    }
+    [customInspectSymbolStackLess](depth, options) {
+      const validator = options.stylize(this.validator, "string");
+      if (depth < 0) {
+        return options.stylize(`[ValidationError: ${validator}]`, "special");
+      }
+      const newOptions = { ...options, depth: options.depth === null ? null : options.depth - 1, compact: true };
+      const padding = `
+  ${options.stylize("|", "undefined")} `;
+      const given = inspect2(this.given, newOptions).replace(/\n/g, padding);
+      const header = `${options.stylize("ValidationError", "special")} > ${validator}`;
+      const message = options.stylize(this.message, "regexp");
+      const givenBlock = `
+  ${options.stylize("Received:", "regexp")}${padding}${given}`;
+      return `${header}
+  ${message}
+${givenBlock}`;
+    }
+  };
+  __name(ValidationError, "ValidationError");
+
+  // src/validators/ArrayValidator.ts
+  var ArrayValidator = class extends BaseValidator {
+    constructor(validator, constraints = []) {
+      super(constraints);
+      this.validator = validator;
+    }
+    lengthLessThan(length) {
+      return this.addConstraint(arrayLengthLessThan(length));
+    }
+    lengthLessThanOrEqual(length) {
+      return this.addConstraint(arrayLengthLessThanOrEqual(length));
+    }
+    lengthGreaterThan(length) {
+      return this.addConstraint(arrayLengthGreaterThan(length));
+    }
+    lengthGreaterThanOrEqual(length) {
+      return this.addConstraint(arrayLengthGreaterThanOrEqual(length));
+    }
+    lengthEqual(length) {
+      return this.addConstraint(arrayLengthEqual(length));
+    }
+    lengthNotEqual(length) {
+      return this.addConstraint(arrayLengthNotEqual(length));
+    }
+    lengthRange(start, endBefore) {
+      return this.addConstraint(arrayLengthRange(start, endBefore));
+    }
+    lengthRangeInclusive(startAt, endAt) {
+      return this.addConstraint(arrayLengthRangeInclusive(startAt, endAt));
+    }
+    lengthRangeExclusive(startAfter, endBefore) {
+      return this.addConstraint(arrayLengthRangeExclusive(startAfter, endBefore));
+    }
+    get unique() {
+      return this.addConstraint(uniqueArray);
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.validator, this.constraints]);
+    }
+    handle(values) {
+      if (!Array.isArray(values)) {
+        return Result.err(new ValidationError("s.array(T)", "Expected an array", values));
+      }
+      if (!this.shouldRunConstraints) {
+        return Result.ok(values);
+      }
+      const errors = [];
+      const transformed = [];
+      for (let i3 = 0; i3 < values.length; i3++) {
+        const result = this.validator.run(values[i3]);
+        if (result.isOk())
+          transformed.push(result.value);
+        else
+          errors.push([i3, result.error]);
+      }
+      return errors.length === 0 ? Result.ok(transformed) : Result.err(new CombinedPropertyError(errors));
+    }
+  };
+  __name(ArrayValidator, "ArrayValidator");
+
+  // src/constraints/BigIntConstraints.ts
+  function bigintComparator(comparator, name, expected, number) {
+    return {
+      run(input) {
+        return comparator(input, number) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, "Invalid bigint value", input, expected));
+      }
+    };
+  }
+  __name(bigintComparator, "bigintComparator");
+  function bigintLessThan(value) {
+    const expected = `expected < ${value}n`;
+    return bigintComparator(lessThan, "s.bigint.lessThan", expected, value);
+  }
+  __name(bigintLessThan, "bigintLessThan");
+  function bigintLessThanOrEqual(value) {
+    const expected = `expected <= ${value}n`;
+    return bigintComparator(lessThanOrEqual, "s.bigint.lessThanOrEqual", expected, value);
+  }
+  __name(bigintLessThanOrEqual, "bigintLessThanOrEqual");
+  function bigintGreaterThan(value) {
+    const expected = `expected > ${value}n`;
+    return bigintComparator(greaterThan, "s.bigint.greaterThan", expected, value);
+  }
+  __name(bigintGreaterThan, "bigintGreaterThan");
+  function bigintGreaterThanOrEqual(value) {
+    const expected = `expected >= ${value}n`;
+    return bigintComparator(greaterThanOrEqual, "s.bigint.greaterThanOrEqual", expected, value);
+  }
+  __name(bigintGreaterThanOrEqual, "bigintGreaterThanOrEqual");
+  function bigintEqual(value) {
+    const expected = `expected === ${value}n`;
+    return bigintComparator(equal, "s.bigint.equal", expected, value);
+  }
+  __name(bigintEqual, "bigintEqual");
+  function bigintNotEqual(value) {
+    const expected = `expected !== ${value}n`;
+    return bigintComparator(notEqual, "s.bigint.notEqual", expected, value);
+  }
+  __name(bigintNotEqual, "bigintNotEqual");
+  function bigintDivisibleBy(divider) {
+    const expected = `expected % ${divider}n === 0n`;
+    return {
+      run(input) {
+        return input % divider === 0n ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.bigint.divisibleBy", "BigInt is not divisible", input, expected));
+      }
+    };
+  }
+  __name(bigintDivisibleBy, "bigintDivisibleBy");
+
+  // src/validators/BigIntValidator.ts
+  var BigIntValidator = class extends BaseValidator {
+    lessThan(number) {
+      return this.addConstraint(bigintLessThan(number));
+    }
+    lessThanOrEqual(number) {
+      return this.addConstraint(bigintLessThanOrEqual(number));
+    }
+    greaterThan(number) {
+      return this.addConstraint(bigintGreaterThan(number));
+    }
+    greaterThanOrEqual(number) {
+      return this.addConstraint(bigintGreaterThanOrEqual(number));
+    }
+    equal(number) {
+      return this.addConstraint(bigintEqual(number));
+    }
+    notEqual(number) {
+      return this.addConstraint(bigintNotEqual(number));
+    }
+    get positive() {
+      return this.greaterThanOrEqual(0n);
+    }
+    get negative() {
+      return this.lessThan(0n);
+    }
+    divisibleBy(number) {
+      return this.addConstraint(bigintDivisibleBy(number));
+    }
+    get abs() {
+      return this.transform((value) => value < 0 ? -value : value);
+    }
+    intN(bits) {
+      return this.transform((value) => BigInt.asIntN(bits, value));
+    }
+    uintN(bits) {
+      return this.transform((value) => BigInt.asUintN(bits, value));
+    }
+    handle(value) {
+      return typeof value === "bigint" ? Result.ok(value) : Result.err(new ValidationError("s.bigint", "Expected a bigint primitive", value));
+    }
+  };
+  __name(BigIntValidator, "BigIntValidator");
+
+  // src/constraints/BooleanConstraints.ts
+  var booleanTrue = {
+    run(input) {
+      return input ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.boolean.true", "Invalid boolean value", input, "true"));
+    }
+  };
+  var booleanFalse = {
+    run(input) {
+      return input ? Result.err(new ExpectedConstraintError("s.boolean.false", "Invalid boolean value", input, "false")) : Result.ok(input);
+    }
+  };
+
+  // src/validators/BooleanValidator.ts
+  var BooleanValidator = class extends BaseValidator {
+    get true() {
+      return this.addConstraint(booleanTrue);
+    }
+    get false() {
+      return this.addConstraint(booleanFalse);
+    }
+    equal(value) {
+      return value ? this.true : this.false;
+    }
+    notEqual(value) {
+      return value ? this.false : this.true;
+    }
+    handle(value) {
+      return typeof value === "boolean" ? Result.ok(value) : Result.err(new ValidationError("s.boolean", "Expected a boolean primitive", value));
+    }
+  };
+  __name(BooleanValidator, "BooleanValidator");
+
+  // src/constraints/DateConstraints.ts
+  function dateComparator(comparator, name, expected, number) {
+    return {
+      run(input) {
+        return comparator(input.getTime(), number) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, "Invalid Date value", input, expected));
+      }
+    };
+  }
+  __name(dateComparator, "dateComparator");
+  function dateLessThan(value) {
+    const expected = `expected < ${value.toISOString()}`;
+    return dateComparator(lessThan, "s.date.lessThan", expected, value.getTime());
+  }
+  __name(dateLessThan, "dateLessThan");
+  function dateLessThanOrEqual(value) {
+    const expected = `expected <= ${value.toISOString()}`;
+    return dateComparator(lessThanOrEqual, "s.date.lessThanOrEqual", expected, value.getTime());
+  }
+  __name(dateLessThanOrEqual, "dateLessThanOrEqual");
+  function dateGreaterThan(value) {
+    const expected = `expected > ${value.toISOString()}`;
+    return dateComparator(greaterThan, "s.date.greaterThan", expected, value.getTime());
+  }
+  __name(dateGreaterThan, "dateGreaterThan");
+  function dateGreaterThanOrEqual(value) {
+    const expected = `expected >= ${value.toISOString()}`;
+    return dateComparator(greaterThanOrEqual, "s.date.greaterThanOrEqual", expected, value.getTime());
+  }
+  __name(dateGreaterThanOrEqual, "dateGreaterThanOrEqual");
+  function dateEqual(value) {
+    const expected = `expected === ${value.toISOString()}`;
+    return dateComparator(equal, "s.date.equal", expected, value.getTime());
+  }
+  __name(dateEqual, "dateEqual");
+  function dateNotEqual(value) {
+    const expected = `expected !== ${value.toISOString()}`;
+    return dateComparator(notEqual, "s.date.notEqual", expected, value.getTime());
+  }
+  __name(dateNotEqual, "dateNotEqual");
+  var dateInvalid = {
+    run(input) {
+      return Number.isNaN(input.getTime()) ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.date.invalid", "Invalid Date value", input, "expected === NaN"));
+    }
+  };
+  var dateValid = {
+    run(input) {
+      return Number.isNaN(input.getTime()) ? Result.err(new ExpectedConstraintError("s.date.valid", "Invalid Date value", input, "expected !== NaN")) : Result.ok(input);
+    }
+  };
+
+  // src/validators/DateValidator.ts
+  var DateValidator = class extends BaseValidator {
+    lessThan(date) {
+      return this.addConstraint(dateLessThan(new Date(date)));
+    }
+    lessThanOrEqual(date) {
+      return this.addConstraint(dateLessThanOrEqual(new Date(date)));
+    }
+    greaterThan(date) {
+      return this.addConstraint(dateGreaterThan(new Date(date)));
+    }
+    greaterThanOrEqual(date) {
+      return this.addConstraint(dateGreaterThanOrEqual(new Date(date)));
+    }
+    equal(date) {
+      const resolved = new Date(date);
+      return Number.isNaN(resolved.getTime()) ? this.invalid : this.addConstraint(dateEqual(resolved));
+    }
+    notEqual(date) {
+      const resolved = new Date(date);
+      return Number.isNaN(resolved.getTime()) ? this.valid : this.addConstraint(dateNotEqual(resolved));
+    }
+    get valid() {
+      return this.addConstraint(dateValid);
+    }
+    get invalid() {
+      return this.addConstraint(dateInvalid);
+    }
+    handle(value) {
+      return value instanceof Date ? Result.ok(value) : Result.err(new ValidationError("s.date", "Expected a Date", value));
+    }
+  };
+  __name(DateValidator, "DateValidator");
+
+  // src/lib/errors/ExpectedValidationError.ts
+  var ExpectedValidationError = class extends ValidationError {
+    constructor(validator, message, given, expected) {
+      super(validator, message, given);
+      this.expected = expected;
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        validator: this.validator,
+        given: this.given,
+        expected: this.expected
+      };
+    }
+    [customInspectSymbolStackLess](depth, options) {
+      const validator = options.stylize(this.validator, "string");
+      if (depth < 0) {
+        return options.stylize(`[ExpectedValidationError: ${validator}]`, "special");
+      }
+      const newOptions = { ...options, depth: options.depth === null ? null : options.depth - 1 };
+      const padding = `
+  ${options.stylize("|", "undefined")} `;
+      const expected = inspect2(this.expected, newOptions).replace(/\n/g, padding);
+      const given = inspect2(this.given, newOptions).replace(/\n/g, padding);
+      const header = `${options.stylize("ExpectedValidationError", "special")} > ${validator}`;
+      const message = options.stylize(this.message, "regexp");
+      const expectedBlock = `
+  ${options.stylize("Expected:", "string")}${padding}${expected}`;
+      const givenBlock = `
+  ${options.stylize("Received:", "regexp")}${padding}${given}`;
+      return `${header}
+  ${message}
+${expectedBlock}
+${givenBlock}`;
+    }
+  };
+  __name(ExpectedValidationError, "ExpectedValidationError");
+
+  // src/validators/InstanceValidator.ts
+  var InstanceValidator = class extends BaseValidator {
+    constructor(expected, constraints = []) {
+      super(constraints);
+      this.expected = expected;
+    }
+    handle(value) {
+      return value instanceof this.expected ? Result.ok(value) : Result.err(new ExpectedValidationError("s.instance(V)", "Expected", value, this.expected));
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.expected, this.constraints]);
+    }
+  };
+  __name(InstanceValidator, "InstanceValidator");
+
+  // src/validators/LiteralValidator.ts
+  var LiteralValidator = class extends BaseValidator {
+    constructor(literal, constraints = []) {
+      super(constraints);
+      this.expected = literal;
+    }
+    handle(value) {
+      return Object.is(value, this.expected) ? Result.ok(value) : Result.err(new ExpectedValidationError("s.literal(V)", "Expected values to be equals", value, this.expected));
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.expected, this.constraints]);
+    }
+  };
+  __name(LiteralValidator, "LiteralValidator");
+
+  // src/validators/NeverValidator.ts
+  var NeverValidator = class extends BaseValidator {
+    handle(value) {
+      return Result.err(new ValidationError("s.never", "Expected a value to not be passed", value));
+    }
+  };
+  __name(NeverValidator, "NeverValidator");
+
+  // src/validators/NullishValidator.ts
+  var NullishValidator = class extends BaseValidator {
+    handle(value) {
+      return value === void 0 || value === null ? Result.ok(value) : Result.err(new ValidationError("s.nullish", "Expected undefined or null", value));
+    }
+  };
+  __name(NullishValidator, "NullishValidator");
+
+  // src/constraints/NumberConstraints.ts
+  function numberComparator(comparator, name, expected, number) {
+    return {
+      run(input) {
+        return comparator(input, number) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, "Invalid number value", input, expected));
+      }
+    };
+  }
+  __name(numberComparator, "numberComparator");
+  function numberLessThan(value) {
+    const expected = `expected < ${value}`;
+    return numberComparator(lessThan, "s.number.lessThan", expected, value);
+  }
+  __name(numberLessThan, "numberLessThan");
+  function numberLessThanOrEqual(value) {
+    const expected = `expected <= ${value}`;
+    return numberComparator(lessThanOrEqual, "s.number.lessThanOrEqual", expected, value);
+  }
+  __name(numberLessThanOrEqual, "numberLessThanOrEqual");
+  function numberGreaterThan(value) {
+    const expected = `expected > ${value}`;
+    return numberComparator(greaterThan, "s.number.greaterThan", expected, value);
+  }
+  __name(numberGreaterThan, "numberGreaterThan");
+  function numberGreaterThanOrEqual(value) {
+    const expected = `expected >= ${value}`;
+    return numberComparator(greaterThanOrEqual, "s.number.greaterThanOrEqual", expected, value);
+  }
+  __name(numberGreaterThanOrEqual, "numberGreaterThanOrEqual");
+  function numberEqual(value) {
+    const expected = `expected === ${value}`;
+    return numberComparator(equal, "s.number.equal", expected, value);
+  }
+  __name(numberEqual, "numberEqual");
+  function numberNotEqual(value) {
+    const expected = `expected !== ${value}`;
+    return numberComparator(notEqual, "s.number.notEqual", expected, value);
+  }
+  __name(numberNotEqual, "numberNotEqual");
+  var numberInt = {
+    run(input) {
+      return Number.isInteger(input) ? Result.ok(input) : Result.err(
+        new ExpectedConstraintError("s.number.int", "Given value is not an integer", input, "Number.isInteger(expected) to be true")
+      );
+    }
+  };
+  var numberSafeInt = {
+    run(input) {
+      return Number.isSafeInteger(input) ? Result.ok(input) : Result.err(
+        new ExpectedConstraintError(
+          "s.number.safeInt",
+          "Given value is not a safe integer",
+          input,
+          "Number.isSafeInteger(expected) to be true"
+        )
+      );
+    }
+  };
+  var numberFinite = {
+    run(input) {
+      return Number.isFinite(input) ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.number.finite", "Given value is not finite", input, "Number.isFinite(expected) to be true"));
+    }
+  };
+  var numberNaN = {
+    run(input) {
+      return Number.isNaN(input) ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.number.equal(NaN)", "Invalid number value", input, "expected === NaN"));
+    }
+  };
+  var numberNotNaN = {
+    run(input) {
+      return Number.isNaN(input) ? Result.err(new ExpectedConstraintError("s.number.notEqual(NaN)", "Invalid number value", input, "expected !== NaN")) : Result.ok(input);
+    }
+  };
+  function numberDivisibleBy(divider) {
+    const expected = `expected % ${divider} === 0`;
+    return {
+      run(input) {
+        return input % divider === 0 ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.number.divisibleBy", "Number is not divisible", input, expected));
+      }
+    };
+  }
+  __name(numberDivisibleBy, "numberDivisibleBy");
+
+  // src/validators/NumberValidator.ts
+  var NumberValidator = class extends BaseValidator {
+    lessThan(number) {
+      return this.addConstraint(numberLessThan(number));
+    }
+    lessThanOrEqual(number) {
+      return this.addConstraint(numberLessThanOrEqual(number));
+    }
+    greaterThan(number) {
+      return this.addConstraint(numberGreaterThan(number));
+    }
+    greaterThanOrEqual(number) {
+      return this.addConstraint(numberGreaterThanOrEqual(number));
+    }
+    equal(number) {
+      return Number.isNaN(number) ? this.addConstraint(numberNaN) : this.addConstraint(numberEqual(number));
+    }
+    notEqual(number) {
+      return Number.isNaN(number) ? this.addConstraint(numberNotNaN) : this.addConstraint(numberNotEqual(number));
+    }
+    get int() {
+      return this.addConstraint(numberInt);
+    }
+    get safeInt() {
+      return this.addConstraint(numberSafeInt);
+    }
+    get finite() {
+      return this.addConstraint(numberFinite);
+    }
+    get positive() {
+      return this.greaterThanOrEqual(0);
+    }
+    get negative() {
+      return this.lessThan(0);
+    }
+    divisibleBy(divider) {
+      return this.addConstraint(numberDivisibleBy(divider));
+    }
+    get abs() {
+      return this.transform(Math.abs);
+    }
+    get sign() {
+      return this.transform(Math.sign);
+    }
+    get trunc() {
+      return this.transform(Math.trunc);
+    }
+    get floor() {
+      return this.transform(Math.floor);
+    }
+    get fround() {
+      return this.transform(Math.fround);
+    }
+    get round() {
+      return this.transform(Math.round);
+    }
+    get ceil() {
+      return this.transform(Math.ceil);
+    }
+    handle(value) {
+      return typeof value === "number" ? Result.ok(value) : Result.err(new ValidationError("s.number", "Expected a number primitive", value));
+    }
+  };
+  __name(NumberValidator, "NumberValidator");
+
+  // src/lib/errors/MissingPropertyError.ts
+  var MissingPropertyError = class extends BaseError {
+    constructor(property) {
+      super("A required property is missing");
+      this.property = property;
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        property: this.property
+      };
+    }
+    [customInspectSymbolStackLess](depth, options) {
+      const property = options.stylize(this.property.toString(), "string");
+      if (depth < 0) {
+        return options.stylize(`[MissingPropertyError: ${property}]`, "special");
+      }
+      const header = `${options.stylize("MissingPropertyError", "special")} > ${property}`;
+      const message = options.stylize(this.message, "regexp");
+      return `${header}
+  ${message}`;
+    }
+  };
+  __name(MissingPropertyError, "MissingPropertyError");
+
+  // src/lib/errors/UnknownPropertyError.ts
+  var UnknownPropertyError = class extends BaseError {
+    constructor(property, value) {
+      super("Received unexpected property");
+      this.property = property;
+      this.value = value;
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        property: this.property,
+        value: this.value
+      };
+    }
+    [customInspectSymbolStackLess](depth, options) {
+      const property = options.stylize(this.property.toString(), "string");
+      if (depth < 0) {
+        return options.stylize(`[UnknownPropertyError: ${property}]`, "special");
+      }
+      const newOptions = { ...options, depth: options.depth === null ? null : options.depth - 1, compact: true };
+      const padding = `
+  ${options.stylize("|", "undefined")} `;
+      const given = inspect2(this.value, newOptions).replace(/\n/g, padding);
+      const header = `${options.stylize("UnknownPropertyError", "special")} > ${property}`;
+      const message = options.stylize(this.message, "regexp");
+      const givenBlock = `
+  ${options.stylize("Received:", "regexp")}${padding}${given}`;
+      return `${header}
+  ${message}
+${givenBlock}`;
+    }
+  };
+  __name(UnknownPropertyError, "UnknownPropertyError");
+
+  // src/validators/DefaultValidator.ts
+  var DefaultValidator = class extends BaseValidator {
+    constructor(validator, value, constraints = []) {
+      super(constraints);
+      this.validator = validator;
+      this.defaultValue = value;
+    }
+    default(value) {
+      const clone = this.clone();
+      clone.defaultValue = value;
+      return clone;
+    }
+    handle(value) {
+      return typeof value === "undefined" ? Result.ok(getValue(this.defaultValue)) : this.validator["handle"](value);
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.validator, this.defaultValue, this.constraints]);
+    }
+  };
+  __name(DefaultValidator, "DefaultValidator");
+
+  // src/lib/errors/CombinedError.ts
+  var CombinedError = class extends BaseError {
+    constructor(errors) {
+      super("Received one or more errors");
+      this.errors = errors;
+    }
+    [customInspectSymbolStackLess](depth, options) {
+      if (depth < 0) {
+        return options.stylize("[CombinedError]", "special");
+      }
+      const newOptions = { ...options, depth: options.depth === null ? null : options.depth - 1, compact: true };
+      const padding = `
+  ${options.stylize("|", "undefined")} `;
+      const header = `${options.stylize("CombinedError", "special")} (${options.stylize(this.errors.length.toString(), "number")})`;
+      const message = options.stylize(this.message, "regexp");
+      const errors = this.errors.map((error, i3) => {
+        const index = options.stylize((i3 + 1).toString(), "number");
+        const body = error[customInspectSymbolStackLess](depth - 1, newOptions).replace(/\n/g, padding);
+        return `  ${index} ${body}`;
+      }).join("\n\n");
+      return `${header}
+  ${message}
+
+${errors}`;
+    }
+  };
+  __name(CombinedError, "CombinedError");
+
+  // src/validators/UnionValidator.ts
+  var UnionValidator = class extends BaseValidator {
+    constructor(validators, constraints = []) {
+      super(constraints);
+      this.validators = validators;
+    }
+    get optional() {
+      if (this.validators.length === 0)
+        return new UnionValidator([new LiteralValidator(void 0)], this.constraints);
+      const [validator] = this.validators;
+      if (validator instanceof LiteralValidator) {
+        if (validator.expected === void 0)
+          return this.clone();
+        if (validator.expected === null) {
+          return new UnionValidator(
+            [new NullishValidator(), ...this.validators.slice(1)],
+            this.constraints
+          );
+        }
+      } else if (validator instanceof NullishValidator) {
+        return this.clone();
+      }
+      return new UnionValidator([new LiteralValidator(void 0), ...this.validators]);
+    }
+    get required() {
+      if (this.validators.length === 0)
+        return this.clone();
+      const [validator] = this.validators;
+      if (validator instanceof LiteralValidator) {
+        if (validator.expected === void 0)
+          return new UnionValidator(this.validators.slice(1), this.constraints);
+      } else if (validator instanceof NullishValidator) {
+        return new UnionValidator([new LiteralValidator(null), ...this.validators.slice(1)], this.constraints);
+      }
+      return this.clone();
+    }
+    get nullable() {
+      if (this.validators.length === 0)
+        return new UnionValidator([new LiteralValidator(null)], this.constraints);
+      const [validator] = this.validators;
+      if (validator instanceof LiteralValidator) {
+        if (validator.expected === null)
+          return this.clone();
+        if (validator.expected === void 0) {
+          return new UnionValidator(
+            [new NullishValidator(), ...this.validators.slice(1)],
+            this.constraints
+          );
+        }
+      } else if (validator instanceof NullishValidator) {
+        return this.clone();
+      }
+      return new UnionValidator([new LiteralValidator(null), ...this.validators]);
+    }
+    get nullish() {
+      if (this.validators.length === 0)
+        return new UnionValidator([new NullishValidator()], this.constraints);
+      const [validator] = this.validators;
+      if (validator instanceof LiteralValidator) {
+        if (validator.expected === null || validator.expected === void 0) {
+          return new UnionValidator([new NullishValidator(), ...this.validators.slice(1)], this.constraints);
+        }
+      } else if (validator instanceof NullishValidator) {
+        return this.clone();
+      }
+      return new UnionValidator([new NullishValidator(), ...this.validators]);
+    }
+    or(...predicates) {
+      return new UnionValidator([...this.validators, ...predicates]);
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.validators, this.constraints]);
+    }
+    handle(value) {
+      const errors = [];
+      for (const validator of this.validators) {
+        const result = validator.run(value);
+        if (result.isOk())
+          return result;
+        errors.push(result.error);
+      }
+      return Result.err(new CombinedError(errors));
+    }
+  };
+  __name(UnionValidator, "UnionValidator");
+
+  // src/validators/ObjectValidator.ts
+  var ObjectValidator = class extends BaseValidator {
+    constructor(shape, strategy = 0 /* Ignore */, constraints = []) {
+      super(constraints);
+      this.keys = [];
+      this.requiredKeys = /* @__PURE__ */ new Map();
+      this.possiblyUndefinedKeys = /* @__PURE__ */ new Map();
+      this.possiblyUndefinedKeysWithDefaults = /* @__PURE__ */ new Map();
+      this.shape = shape;
+      this.strategy = strategy;
+      switch (this.strategy) {
+        case 0 /* Ignore */:
+          this.handleStrategy = (value) => this.handleIgnoreStrategy(value);
+          break;
+        case 1 /* Strict */: {
+          this.handleStrategy = (value) => this.handleStrictStrategy(value);
+          break;
+        }
+        case 2 /* Passthrough */:
+          this.handleStrategy = (value) => this.handlePassthroughStrategy(value);
+          break;
+      }
+      const shapeEntries = Object.entries(shape);
+      this.keys = shapeEntries.map(([key]) => key);
+      for (const [key, validator] of shapeEntries) {
+        if (validator instanceof UnionValidator) {
+          const [possiblyLiteralOrNullishPredicate] = validator["validators"];
+          if (possiblyLiteralOrNullishPredicate instanceof NullishValidator) {
+            this.possiblyUndefinedKeys.set(key, validator);
+          } else if (possiblyLiteralOrNullishPredicate instanceof LiteralValidator) {
+            if (possiblyLiteralOrNullishPredicate.expected === void 0) {
+              this.possiblyUndefinedKeys.set(key, validator);
+            } else {
+              this.requiredKeys.set(key, validator);
+            }
+          } else if (validator instanceof DefaultValidator) {
+            this.possiblyUndefinedKeysWithDefaults.set(key, validator);
+          } else {
+            this.requiredKeys.set(key, validator);
+          }
+        } else if (validator instanceof NullishValidator) {
+          this.possiblyUndefinedKeys.set(key, validator);
+        } else if (validator instanceof LiteralValidator) {
+          if (validator.expected === void 0) {
+            this.possiblyUndefinedKeys.set(key, validator);
+          } else {
+            this.requiredKeys.set(key, validator);
+          }
+        } else if (validator instanceof DefaultValidator) {
+          this.possiblyUndefinedKeysWithDefaults.set(key, validator);
+        } else {
+          this.requiredKeys.set(key, validator);
+        }
+      }
+    }
+    get strict() {
+      return Reflect.construct(this.constructor, [this.shape, 1 /* Strict */, this.constraints]);
+    }
+    get ignore() {
+      return Reflect.construct(this.constructor, [this.shape, 0 /* Ignore */, this.constraints]);
+    }
+    get passthrough() {
+      return Reflect.construct(this.constructor, [this.shape, 2 /* Passthrough */, this.constraints]);
+    }
+    get partial() {
+      const shape = Object.fromEntries(this.keys.map((key) => [key, this.shape[key].optional]));
+      return Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);
+    }
+    get required() {
+      const shape = Object.fromEntries(
+        this.keys.map((key) => {
+          let validator = this.shape[key];
+          if (validator instanceof UnionValidator)
+            validator = validator.required;
+          return [key, validator];
+        })
+      );
+      return Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);
+    }
+    extend(schema) {
+      const shape = { ...this.shape, ...schema instanceof ObjectValidator ? schema.shape : schema };
+      return Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);
+    }
+    pick(keys) {
+      const shape = Object.fromEntries(
+        keys.filter((key) => this.keys.includes(key)).map((key) => [key, this.shape[key]])
+      );
+      return Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);
+    }
+    omit(keys) {
+      const shape = Object.fromEntries(
+        this.keys.filter((key) => !keys.includes(key)).map((key) => [key, this.shape[key]])
+      );
+      return Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);
+    }
+    handle(value) {
+      const typeOfValue = typeof value;
+      if (typeOfValue !== "object") {
+        return Result.err(new ValidationError("s.object(T)", `Expected the value to be an object, but received ${typeOfValue} instead`, value));
+      }
+      if (value === null) {
+        return Result.err(new ValidationError("s.object(T)", "Expected the value to not be null", value));
+      }
+      if (Array.isArray(value)) {
+        return Result.err(new ValidationError("s.object(T)", "Expected the value to not be an array", value));
+      }
+      if (!this.shouldRunConstraints) {
+        return Result.ok(value);
+      }
+      for (const predicate of Object.values(this.shape)) {
+        predicate.setParent(this.parent ?? value);
+      }
+      return this.handleStrategy(value);
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.shape, this.strategy, this.constraints]);
+    }
+    handleIgnoreStrategy(value) {
+      const errors = [];
+      const finalObject = {};
+      const inputEntries = new Map(Object.entries(value));
+      const runPredicate = /* @__PURE__ */ __name((key, predicate) => {
+        const result = predicate.run(value[key]);
+        if (result.isOk()) {
+          finalObject[key] = result.value;
+        } else {
+          const error = result.error;
+          errors.push([key, error]);
+        }
+      }, "runPredicate");
+      for (const [key, predicate] of this.requiredKeys) {
+        if (inputEntries.delete(key)) {
+          runPredicate(key, predicate);
+        } else {
+          errors.push([key, new MissingPropertyError(key)]);
+        }
+      }
+      for (const [key, validator] of this.possiblyUndefinedKeysWithDefaults) {
+        inputEntries.delete(key);
+        runPredicate(key, validator);
+      }
+      if (inputEntries.size === 0) {
+        return errors.length === 0 ? Result.ok(finalObject) : Result.err(new CombinedPropertyError(errors));
+      }
+      const checkInputEntriesInsteadOfSchemaKeys = this.possiblyUndefinedKeys.size > inputEntries.size;
+      if (checkInputEntriesInsteadOfSchemaKeys) {
+        for (const [key] of inputEntries) {
+          const predicate = this.possiblyUndefinedKeys.get(key);
+          if (predicate) {
+            runPredicate(key, predicate);
+          }
+        }
+      } else {
+        for (const [key, predicate] of this.possiblyUndefinedKeys) {
+          if (inputEntries.delete(key)) {
+            runPredicate(key, predicate);
+          }
+        }
+      }
+      return errors.length === 0 ? Result.ok(finalObject) : Result.err(new CombinedPropertyError(errors));
+    }
+    handleStrictStrategy(value) {
+      const errors = [];
+      const finalResult = {};
+      const inputEntries = new Map(Object.entries(value));
+      const runPredicate = /* @__PURE__ */ __name((key, predicate) => {
+        const result = predicate.run(value[key]);
+        if (result.isOk()) {
+          finalResult[key] = result.value;
+        } else {
+          const error = result.error;
+          errors.push([key, error]);
+        }
+      }, "runPredicate");
+      for (const [key, predicate] of this.requiredKeys) {
+        if (inputEntries.delete(key)) {
+          runPredicate(key, predicate);
+        } else {
+          errors.push([key, new MissingPropertyError(key)]);
+        }
+      }
+      for (const [key, validator] of this.possiblyUndefinedKeysWithDefaults) {
+        inputEntries.delete(key);
+        runPredicate(key, validator);
+      }
+      for (const [key, predicate] of this.possiblyUndefinedKeys) {
+        if (inputEntries.size === 0) {
+          break;
+        }
+        if (inputEntries.delete(key)) {
+          runPredicate(key, predicate);
+        }
+      }
+      if (inputEntries.size !== 0) {
+        for (const [key, value2] of inputEntries.entries()) {
+          errors.push([key, new UnknownPropertyError(key, value2)]);
+        }
+      }
+      return errors.length === 0 ? Result.ok(finalResult) : Result.err(new CombinedPropertyError(errors));
+    }
+    handlePassthroughStrategy(value) {
+      const result = this.handleIgnoreStrategy(value);
+      return result.isErr() ? result : Result.ok({ ...value, ...result.value });
+    }
+  };
+  __name(ObjectValidator, "ObjectValidator");
+
+  // src/validators/PassthroughValidator.ts
+  var PassthroughValidator = class extends BaseValidator {
+    handle(value) {
+      return Result.ok(value);
+    }
+  };
+  __name(PassthroughValidator, "PassthroughValidator");
+
+  // src/validators/RecordValidator.ts
+  var RecordValidator = class extends BaseValidator {
+    constructor(validator, constraints = []) {
+      super(constraints);
+      this.validator = validator;
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.validator, this.constraints]);
+    }
+    handle(value) {
+      if (typeof value !== "object") {
+        return Result.err(new ValidationError("s.record(T)", "Expected an object", value));
+      }
+      if (value === null) {
+        return Result.err(new ValidationError("s.record(T)", "Expected the value to not be null", value));
+      }
+      if (Array.isArray(value)) {
+        return Result.err(new ValidationError("s.record(T)", "Expected the value to not be an array", value));
+      }
+      if (!this.shouldRunConstraints) {
+        return Result.ok(value);
+      }
+      const errors = [];
+      const transformed = {};
+      for (const [key, val] of Object.entries(value)) {
+        const result = this.validator.run(val);
+        if (result.isOk())
+          transformed[key] = result.value;
+        else
+          errors.push([key, result.error]);
+      }
+      return errors.length === 0 ? Result.ok(transformed) : Result.err(new CombinedPropertyError(errors));
+    }
+  };
+  __name(RecordValidator, "RecordValidator");
+
+  // src/validators/SetValidator.ts
+  var SetValidator = class extends BaseValidator {
+    constructor(validator, constraints = []) {
+      super(constraints);
+      this.validator = validator;
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.validator, this.constraints]);
+    }
+    handle(values) {
+      if (!(values instanceof Set)) {
+        return Result.err(new ValidationError("s.set(T)", "Expected a set", values));
+      }
+      if (!this.shouldRunConstraints) {
+        return Result.ok(values);
+      }
+      const errors = [];
+      const transformed = /* @__PURE__ */ new Set();
+      for (const value of values) {
+        const result = this.validator.run(value);
+        if (result.isOk())
+          transformed.add(result.value);
+        else
+          errors.push(result.error);
+      }
+      return errors.length === 0 ? Result.ok(transformed) : Result.err(new CombinedError(errors));
+    }
+  };
+  __name(SetValidator, "SetValidator");
+
+  // src/constraints/util/emailValidator.ts
+  var accountRegex = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")$/;
+  function validateEmail(email) {
+    if (!email)
+      return false;
+    const atIndex = email.indexOf("@");
+    if (atIndex === -1)
+      return false;
+    if (atIndex > 64)
+      return false;
+    const domainIndex = atIndex + 1;
+    if (email.includes("@", domainIndex))
+      return false;
+    if (email.length - domainIndex > 255)
+      return false;
+    let dotIndex = email.indexOf(".", domainIndex);
+    if (dotIndex === -1)
+      return false;
+    let lastDotIndex = domainIndex;
+    do {
+      if (dotIndex - lastDotIndex > 63)
+        return false;
+      lastDotIndex = dotIndex + 1;
+    } while ((dotIndex = email.indexOf(".", lastDotIndex)) !== -1);
+    if (email.length - lastDotIndex > 63)
+      return false;
+    return accountRegex.test(email.slice(0, atIndex)) && validateEmailDomain(email.slice(domainIndex));
+  }
+  __name(validateEmail, "validateEmail");
+  function validateEmailDomain(domain) {
+    try {
+      return new URL(`http://${domain}`).hostname === domain;
+    } catch {
+      return false;
+    }
+  }
+  __name(validateEmailDomain, "validateEmailDomain");
+
+  // src/constraints/util/net.ts
+  var v4Seg = "(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";
+  var v4Str = `(${v4Seg}[.]){3}${v4Seg}`;
+  var IPv4Reg = new RegExp(`^${v4Str}$`);
+  var v6Seg = "(?:[0-9a-fA-F]{1,4})";
+  var IPv6Reg = new RegExp(
+    `^((?:${v6Seg}:){7}(?:${v6Seg}|:)|(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})?$`
+  );
+  function isIPv4(s4) {
+    return IPv4Reg.test(s4);
+  }
+  __name(isIPv4, "isIPv4");
+  function isIPv6(s4) {
+    return IPv6Reg.test(s4);
+  }
+  __name(isIPv6, "isIPv6");
+  function isIP(s4) {
+    if (isIPv4(s4))
+      return 4;
+    if (isIPv6(s4))
+      return 6;
+    return 0;
+  }
+  __name(isIP, "isIP");
+
+  // src/constraints/util/phoneValidator.ts
+  var phoneNumberRegex = /^((?:\+|0{0,2})\d{1,2}\s?)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}$/;
+  function validatePhoneNumber(input) {
+    return phoneNumberRegex.test(input);
+  }
+  __name(validatePhoneNumber, "validatePhoneNumber");
+
+  // src/lib/errors/MultiplePossibilitiesConstraintError.ts
+  var MultiplePossibilitiesConstraintError = class extends BaseConstraintError {
+    constructor(constraint, message, given, expected) {
+      super(constraint, message, given);
+      this.expected = expected;
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        constraint: this.constraint,
+        given: this.given,
+        expected: this.expected
+      };
+    }
+    [customInspectSymbolStackLess](depth, options) {
+      const constraint = options.stylize(this.constraint, "string");
+      if (depth < 0) {
+        return options.stylize(`[MultiplePossibilitiesConstraintError: ${constraint}]`, "special");
+      }
+      const newOptions = { ...options, depth: options.depth === null ? null : options.depth - 1 };
+      const verticalLine = options.stylize("|", "undefined");
+      const padding = `
+  ${verticalLine} `;
+      const given = inspect2(this.given, newOptions).replace(/\n/g, padding);
+      const header = `${options.stylize("MultiplePossibilitiesConstraintError", "special")} > ${constraint}`;
+      const message = options.stylize(this.message, "regexp");
+      const expectedPadding = `
+  ${verticalLine} - `;
+      const expectedBlock = `
+  ${options.stylize("Expected any of the following:", "string")}${expectedPadding}${this.expected.map((possible) => options.stylize(possible, "boolean")).join(expectedPadding)}`;
+      const givenBlock = `
+  ${options.stylize("Received:", "regexp")}${padding}${given}`;
+      return `${header}
+  ${message}
+${expectedBlock}
+${givenBlock}`;
+    }
+  };
+  __name(MultiplePossibilitiesConstraintError, "MultiplePossibilitiesConstraintError");
+
+  // src/constraints/util/common/combinedResultFn.ts
+  function combinedErrorFn(...fns) {
+    switch (fns.length) {
+      case 0:
+        return () => null;
+      case 1:
+        return fns[0];
+      case 2: {
+        const [fn0, fn1] = fns;
+        return (...params) => fn0(...params) || fn1(...params);
+      }
+      default: {
+        return (...params) => {
+          for (const fn of fns) {
+            const result = fn(...params);
+            if (result)
+              return result;
+          }
+          return null;
+        };
+      }
+    }
+  }
+  __name(combinedErrorFn, "combinedErrorFn");
+
+  // src/constraints/util/urlValidators.ts
+  function createUrlValidators(options) {
+    const fns = [];
+    if (options?.allowedProtocols?.length)
+      fns.push(allowedProtocolsFn(options.allowedProtocols));
+    if (options?.allowedDomains?.length)
+      fns.push(allowedDomainsFn(options.allowedDomains));
+    return combinedErrorFn(...fns);
+  }
+  __name(createUrlValidators, "createUrlValidators");
+  function allowedProtocolsFn(allowedProtocols) {
+    return (input, url) => allowedProtocols.includes(url.protocol) ? null : new MultiplePossibilitiesConstraintError("s.string.url", "Invalid URL protocol", input, allowedProtocols);
+  }
+  __name(allowedProtocolsFn, "allowedProtocolsFn");
+  function allowedDomainsFn(allowedDomains) {
+    return (input, url) => allowedDomains.includes(url.hostname) ? null : new MultiplePossibilitiesConstraintError("s.string.url", "Invalid URL domain", input, allowedDomains);
+  }
+  __name(allowedDomainsFn, "allowedDomainsFn");
+
+  // src/constraints/StringConstraints.ts
+  function stringLengthComparator(comparator, name, expected, length) {
+    return {
+      run(input) {
+        return comparator(input.length, length) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, "Invalid string length", input, expected));
+      }
+    };
+  }
+  __name(stringLengthComparator, "stringLengthComparator");
+  function stringLengthLessThan(length) {
+    const expected = `expected.length < ${length}`;
+    return stringLengthComparator(lessThan, "s.string.lengthLessThan", expected, length);
+  }
+  __name(stringLengthLessThan, "stringLengthLessThan");
+  function stringLengthLessThanOrEqual(length) {
+    const expected = `expected.length <= ${length}`;
+    return stringLengthComparator(lessThanOrEqual, "s.string.lengthLessThanOrEqual", expected, length);
+  }
+  __name(stringLengthLessThanOrEqual, "stringLengthLessThanOrEqual");
+  function stringLengthGreaterThan(length) {
+    const expected = `expected.length > ${length}`;
+    return stringLengthComparator(greaterThan, "s.string.lengthGreaterThan", expected, length);
+  }
+  __name(stringLengthGreaterThan, "stringLengthGreaterThan");
+  function stringLengthGreaterThanOrEqual(length) {
+    const expected = `expected.length >= ${length}`;
+    return stringLengthComparator(greaterThanOrEqual, "s.string.lengthGreaterThanOrEqual", expected, length);
+  }
+  __name(stringLengthGreaterThanOrEqual, "stringLengthGreaterThanOrEqual");
+  function stringLengthEqual(length) {
+    const expected = `expected.length === ${length}`;
+    return stringLengthComparator(equal, "s.string.lengthEqual", expected, length);
+  }
+  __name(stringLengthEqual, "stringLengthEqual");
+  function stringLengthNotEqual(length) {
+    const expected = `expected.length !== ${length}`;
+    return stringLengthComparator(notEqual, "s.string.lengthNotEqual", expected, length);
+  }
+  __name(stringLengthNotEqual, "stringLengthNotEqual");
+  function stringEmail() {
+    return {
+      run(input) {
+        return validateEmail(input) ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.string.email", "Invalid email address", input, "expected to be an email address"));
+      }
+    };
+  }
+  __name(stringEmail, "stringEmail");
+  function stringRegexValidator(type, expected, regex) {
+    return {
+      run(input) {
+        return regex.test(input) ? Result.ok(input) : Result.err(new ExpectedConstraintError(type, "Invalid string format", input, expected));
+      }
+    };
+  }
+  __name(stringRegexValidator, "stringRegexValidator");
+  function stringUrl(options) {
+    const validatorFn = createUrlValidators(options);
+    return {
+      run(input) {
+        let url;
+        try {
+          url = new URL(input);
+        } catch {
+          return Result.err(new ExpectedConstraintError("s.string.url", "Invalid URL", input, "expected to match a URL"));
+        }
+        const validatorFnResult = validatorFn(input, url);
+        if (validatorFnResult === null)
+          return Result.ok(input);
+        return Result.err(validatorFnResult);
+      }
+    };
+  }
+  __name(stringUrl, "stringUrl");
+  function stringIp(version) {
+    const ipVersion = version ? `v${version}` : "";
+    const validatorFn = version === 4 ? isIPv4 : version === 6 ? isIPv6 : isIP;
+    const name = `s.string.ip${ipVersion}`;
+    const message = `Invalid IP${ipVersion} address`;
+    const expected = `expected to be an IP${ipVersion} address`;
+    return {
+      run(input) {
+        return validatorFn(input) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, message, input, expected));
+      }
+    };
+  }
+  __name(stringIp, "stringIp");
+  function stringRegex(regex) {
+    return stringRegexValidator("s.string.regex", `expected ${regex}.test(expected) to be true`, regex);
+  }
+  __name(stringRegex, "stringRegex");
+  function stringUuid({ version = 4, nullable = false } = {}) {
+    version ?? (version = "1-5");
+    const regex = new RegExp(
+      `^(?:[0-9A-F]{8}-[0-9A-F]{4}-[${version}][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}${nullable ? "|00000000-0000-0000-0000-000000000000" : ""})$`,
+      "i"
+    );
+    const expected = `expected to match UUID${typeof version === "number" ? `v${version}` : ` in range of ${version}`}`;
+    return stringRegexValidator("s.string.uuid", expected, regex);
+  }
+  __name(stringUuid, "stringUuid");
+  function stringDate() {
+    return {
+      run(input) {
+        const time = Date.parse(input);
+        return Number.isNaN(time) ? Result.err(
+          new ExpectedConstraintError(
+            "s.string.date",
+            "Invalid date string",
+            input,
+            "expected to be a valid date string (in the ISO 8601 or ECMA-262 format)"
+          )
+        ) : Result.ok(input);
+      }
+    };
+  }
+  __name(stringDate, "stringDate");
+  function stringPhone() {
+    return {
+      run(input) {
+        return validatePhoneNumber(input) ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.string.phone", "Invalid phone number", input, "expected to be a phone number"));
+      }
+    };
+  }
+  __name(stringPhone, "stringPhone");
+
+  // src/validators/StringValidator.ts
+  var StringValidator = class extends BaseValidator {
+    lengthLessThan(length) {
+      return this.addConstraint(stringLengthLessThan(length));
+    }
+    lengthLessThanOrEqual(length) {
+      return this.addConstraint(stringLengthLessThanOrEqual(length));
+    }
+    lengthGreaterThan(length) {
+      return this.addConstraint(stringLengthGreaterThan(length));
+    }
+    lengthGreaterThanOrEqual(length) {
+      return this.addConstraint(stringLengthGreaterThanOrEqual(length));
+    }
+    lengthEqual(length) {
+      return this.addConstraint(stringLengthEqual(length));
+    }
+    lengthNotEqual(length) {
+      return this.addConstraint(stringLengthNotEqual(length));
+    }
+    get email() {
+      return this.addConstraint(stringEmail());
+    }
+    url(options) {
+      return this.addConstraint(stringUrl(options));
+    }
+    uuid(options) {
+      return this.addConstraint(stringUuid(options));
+    }
+    regex(regex) {
+      return this.addConstraint(stringRegex(regex));
+    }
+    get date() {
+      return this.addConstraint(stringDate());
+    }
+    get ipv4() {
+      return this.ip(4);
+    }
+    get ipv6() {
+      return this.ip(6);
+    }
+    ip(version) {
+      return this.addConstraint(stringIp(version));
+    }
+    phone() {
+      return this.addConstraint(stringPhone());
+    }
+    handle(value) {
+      return typeof value === "string" ? Result.ok(value) : Result.err(new ValidationError("s.string", "Expected a string primitive", value));
+    }
+  };
+  __name(StringValidator, "StringValidator");
+
+  // src/validators/TupleValidator.ts
+  var TupleValidator = class extends BaseValidator {
+    constructor(validators, constraints = []) {
+      super(constraints);
+      this.validators = [];
+      this.validators = validators;
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.validators, this.constraints]);
+    }
+    handle(values) {
+      if (!Array.isArray(values)) {
+        return Result.err(new ValidationError("s.tuple(T)", "Expected an array", values));
+      }
+      if (values.length !== this.validators.length) {
+        return Result.err(new ValidationError("s.tuple(T)", `Expected an array of length ${this.validators.length}`, values));
+      }
+      if (!this.shouldRunConstraints) {
+        return Result.ok(values);
+      }
+      const errors = [];
+      const transformed = [];
+      for (let i3 = 0; i3 < values.length; i3++) {
+        const result = this.validators[i3].run(values[i3]);
+        if (result.isOk())
+          transformed.push(result.value);
+        else
+          errors.push([i3, result.error]);
+      }
+      return errors.length === 0 ? Result.ok(transformed) : Result.err(new CombinedPropertyError(errors));
+    }
+  };
+  __name(TupleValidator, "TupleValidator");
+
+  // src/validators/MapValidator.ts
+  var MapValidator = class extends BaseValidator {
+    constructor(keyValidator, valueValidator, constraints = []) {
+      super(constraints);
+      this.keyValidator = keyValidator;
+      this.valueValidator = valueValidator;
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.keyValidator, this.valueValidator, this.constraints]);
+    }
+    handle(value) {
+      if (!(value instanceof Map)) {
+        return Result.err(new ValidationError("s.map(K, V)", "Expected a map", value));
+      }
+      if (!this.shouldRunConstraints) {
+        return Result.ok(value);
+      }
+      const errors = [];
+      const transformed = /* @__PURE__ */ new Map();
+      for (const [key, val] of value.entries()) {
+        const keyResult = this.keyValidator.run(key);
+        const valueResult = this.valueValidator.run(val);
+        const { length } = errors;
+        if (keyResult.isErr())
+          errors.push([key, keyResult.error]);
+        if (valueResult.isErr())
+          errors.push([key, valueResult.error]);
+        if (errors.length === length)
+          transformed.set(keyResult.value, valueResult.value);
+      }
+      return errors.length === 0 ? Result.ok(transformed) : Result.err(new CombinedPropertyError(errors));
+    }
+  };
+  __name(MapValidator, "MapValidator");
+
+  // src/validators/LazyValidator.ts
+  var LazyValidator = class extends BaseValidator {
+    constructor(validator, constraints = []) {
+      super(constraints);
+      this.validator = validator;
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.validator, this.constraints]);
+    }
+    handle(values) {
+      return this.validator(values).run(values);
+    }
+  };
+  __name(LazyValidator, "LazyValidator");
+
+  // src/lib/errors/UnknownEnumValueError.ts
+  var UnknownEnumValueError = class extends BaseError {
+    constructor(value, keys, enumMappings) {
+      super("Expected the value to be one of the following enum values:");
+      this.value = value;
+      this.enumKeys = keys;
+      this.enumMappings = enumMappings;
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        value: this.value,
+        enumKeys: this.enumKeys,
+        enumMappings: [...this.enumMappings.entries()]
+      };
+    }
+    [customInspectSymbolStackLess](depth, options) {
+      const value = options.stylize(this.value.toString(), "string");
+      if (depth < 0) {
+        return options.stylize(`[UnknownEnumValueError: ${value}]`, "special");
+      }
+      const padding = `
+  ${options.stylize("|", "undefined")} `;
+      const pairs = this.enumKeys.map((key) => {
+        const enumValue = this.enumMappings.get(key);
+        return `${options.stylize(key, "string")} or ${options.stylize(
+        enumValue.toString(),
+        typeof enumValue === "number" ? "number" : "string"
+      )}`;
+      }).join(padding);
+      const header = `${options.stylize("UnknownEnumValueError", "special")} > ${value}`;
+      const message = options.stylize(this.message, "regexp");
+      const pairsBlock = `${padding}${pairs}`;
+      return `${header}
+  ${message}
+${pairsBlock}`;
+    }
+  };
+  __name(UnknownEnumValueError, "UnknownEnumValueError");
+
+  // src/validators/NativeEnumValidator.ts
+  var NativeEnumValidator = class extends BaseValidator {
+    constructor(enumShape) {
+      super();
+      this.hasNumericElements = false;
+      this.enumMapping = /* @__PURE__ */ new Map();
+      this.enumShape = enumShape;
+      this.enumKeys = Object.keys(enumShape).filter((key) => {
+        return typeof enumShape[enumShape[key]] !== "number";
+      });
+      for (const key of this.enumKeys) {
+        const enumValue = enumShape[key];
+        this.enumMapping.set(key, enumValue);
+        this.enumMapping.set(enumValue, enumValue);
+        if (typeof enumValue === "number") {
+          this.hasNumericElements = true;
+          this.enumMapping.set(`${enumValue}`, enumValue);
+        }
+      }
+    }
+    handle(value) {
+      const typeOfValue = typeof value;
+      if (typeOfValue === "number") {
+        if (!this.hasNumericElements) {
+          return Result.err(new ValidationError("s.nativeEnum(T)", "Expected the value to be a string", value));
+        }
+      } else if (typeOfValue !== "string") {
+        return Result.err(new ValidationError("s.nativeEnum(T)", "Expected the value to be a string or number", value));
+      }
+      const casted = value;
+      const possibleEnumValue = this.enumMapping.get(casted);
+      return typeof possibleEnumValue === "undefined" ? Result.err(new UnknownEnumValueError(casted, this.enumKeys, this.enumMapping)) : Result.ok(possibleEnumValue);
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.enumShape]);
+    }
+  };
+  __name(NativeEnumValidator, "NativeEnumValidator");
+
+  // src/constraints/TypedArrayLengthConstraints.ts
+  function typedArrayByteLengthComparator(comparator, name, expected, length) {
+    return {
+      run(input) {
+        return comparator(input.byteLength, length) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, "Invalid Typed Array byte length", input, expected));
+      }
+    };
+  }
+  __name(typedArrayByteLengthComparator, "typedArrayByteLengthComparator");
+  function typedArrayByteLengthLessThan(value) {
+    const expected = `expected.byteLength < ${value}`;
+    return typedArrayByteLengthComparator(lessThan, "s.typedArray(T).byteLengthLessThan", expected, value);
+  }
+  __name(typedArrayByteLengthLessThan, "typedArrayByteLengthLessThan");
+  function typedArrayByteLengthLessThanOrEqual(value) {
+    const expected = `expected.byteLength <= ${value}`;
+    return typedArrayByteLengthComparator(lessThanOrEqual, "s.typedArray(T).byteLengthLessThanOrEqual", expected, value);
+  }
+  __name(typedArrayByteLengthLessThanOrEqual, "typedArrayByteLengthLessThanOrEqual");
+  function typedArrayByteLengthGreaterThan(value) {
+    const expected = `expected.byteLength > ${value}`;
+    return typedArrayByteLengthComparator(greaterThan, "s.typedArray(T).byteLengthGreaterThan", expected, value);
+  }
+  __name(typedArrayByteLengthGreaterThan, "typedArrayByteLengthGreaterThan");
+  function typedArrayByteLengthGreaterThanOrEqual(value) {
+    const expected = `expected.byteLength >= ${value}`;
+    return typedArrayByteLengthComparator(greaterThanOrEqual, "s.typedArray(T).byteLengthGreaterThanOrEqual", expected, value);
+  }
+  __name(typedArrayByteLengthGreaterThanOrEqual, "typedArrayByteLengthGreaterThanOrEqual");
+  function typedArrayByteLengthEqual(value) {
+    const expected = `expected.byteLength === ${value}`;
+    return typedArrayByteLengthComparator(equal, "s.typedArray(T).byteLengthEqual", expected, value);
+  }
+  __name(typedArrayByteLengthEqual, "typedArrayByteLengthEqual");
+  function typedArrayByteLengthNotEqual(value) {
+    const expected = `expected.byteLength !== ${value}`;
+    return typedArrayByteLengthComparator(notEqual, "s.typedArray(T).byteLengthNotEqual", expected, value);
+  }
+  __name(typedArrayByteLengthNotEqual, "typedArrayByteLengthNotEqual");
+  function typedArrayByteLengthRange(start, endBefore) {
+    const expected = `expected.byteLength >= ${start} && expected.byteLength < ${endBefore}`;
+    return {
+      run(input) {
+        return input.byteLength >= start && input.byteLength < endBefore ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.typedArray(T).byteLengthRange", "Invalid Typed Array byte length", input, expected));
+      }
+    };
+  }
+  __name(typedArrayByteLengthRange, "typedArrayByteLengthRange");
+  function typedArrayByteLengthRangeInclusive(start, end) {
+    const expected = `expected.byteLength >= ${start} && expected.byteLength <= ${end}`;
+    return {
+      run(input) {
+        return input.byteLength >= start && input.byteLength <= end ? Result.ok(input) : Result.err(
+          new ExpectedConstraintError("s.typedArray(T).byteLengthRangeInclusive", "Invalid Typed Array byte length", input, expected)
+        );
+      }
+    };
+  }
+  __name(typedArrayByteLengthRangeInclusive, "typedArrayByteLengthRangeInclusive");
+  function typedArrayByteLengthRangeExclusive(startAfter, endBefore) {
+    const expected = `expected.byteLength > ${startAfter} && expected.byteLength < ${endBefore}`;
+    return {
+      run(input) {
+        return input.byteLength > startAfter && input.byteLength < endBefore ? Result.ok(input) : Result.err(
+          new ExpectedConstraintError("s.typedArray(T).byteLengthRangeExclusive", "Invalid Typed Array byte length", input, expected)
+        );
+      }
+    };
+  }
+  __name(typedArrayByteLengthRangeExclusive, "typedArrayByteLengthRangeExclusive");
+  function typedArrayLengthComparator(comparator, name, expected, length) {
+    return {
+      run(input) {
+        return comparator(input.length, length) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, "Invalid Typed Array length", input, expected));
+      }
+    };
+  }
+  __name(typedArrayLengthComparator, "typedArrayLengthComparator");
+  function typedArrayLengthLessThan(value) {
+    const expected = `expected.length < ${value}`;
+    return typedArrayLengthComparator(lessThan, "s.typedArray(T).lengthLessThan", expected, value);
+  }
+  __name(typedArrayLengthLessThan, "typedArrayLengthLessThan");
+  function typedArrayLengthLessThanOrEqual(value) {
+    const expected = `expected.length <= ${value}`;
+    return typedArrayLengthComparator(lessThanOrEqual, "s.typedArray(T).lengthLessThanOrEqual", expected, value);
+  }
+  __name(typedArrayLengthLessThanOrEqual, "typedArrayLengthLessThanOrEqual");
+  function typedArrayLengthGreaterThan(value) {
+    const expected = `expected.length > ${value}`;
+    return typedArrayLengthComparator(greaterThan, "s.typedArray(T).lengthGreaterThan", expected, value);
+  }
+  __name(typedArrayLengthGreaterThan, "typedArrayLengthGreaterThan");
+  function typedArrayLengthGreaterThanOrEqual(value) {
+    const expected = `expected.length >= ${value}`;
+    return typedArrayLengthComparator(greaterThanOrEqual, "s.typedArray(T).lengthGreaterThanOrEqual", expected, value);
+  }
+  __name(typedArrayLengthGreaterThanOrEqual, "typedArrayLengthGreaterThanOrEqual");
+  function typedArrayLengthEqual(value) {
+    const expected = `expected.length === ${value}`;
+    return typedArrayLengthComparator(equal, "s.typedArray(T).lengthEqual", expected, value);
+  }
+  __name(typedArrayLengthEqual, "typedArrayLengthEqual");
+  function typedArrayLengthNotEqual(value) {
+    const expected = `expected.length !== ${value}`;
+    return typedArrayLengthComparator(notEqual, "s.typedArray(T).lengthNotEqual", expected, value);
+  }
+  __name(typedArrayLengthNotEqual, "typedArrayLengthNotEqual");
+  function typedArrayLengthRange(start, endBefore) {
+    const expected = `expected.length >= ${start} && expected.length < ${endBefore}`;
+    return {
+      run(input) {
+        return input.length >= start && input.length < endBefore ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.typedArray(T).lengthRange", "Invalid Typed Array length", input, expected));
+      }
+    };
+  }
+  __name(typedArrayLengthRange, "typedArrayLengthRange");
+  function typedArrayLengthRangeInclusive(start, end) {
+    const expected = `expected.length >= ${start} && expected.length <= ${end}`;
+    return {
+      run(input) {
+        return input.length >= start && input.length <= end ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.typedArray(T).lengthRangeInclusive", "Invalid Typed Array length", input, expected));
+      }
+    };
+  }
+  __name(typedArrayLengthRangeInclusive, "typedArrayLengthRangeInclusive");
+  function typedArrayLengthRangeExclusive(startAfter, endBefore) {
+    const expected = `expected.length > ${startAfter} && expected.length < ${endBefore}`;
+    return {
+      run(input) {
+        return input.length > startAfter && input.length < endBefore ? Result.ok(input) : Result.err(new ExpectedConstraintError("s.typedArray(T).lengthRangeExclusive", "Invalid Typed Array length", input, expected));
+      }
+    };
+  }
+  __name(typedArrayLengthRangeExclusive, "typedArrayLengthRangeExclusive");
+
+  // src/constraints/util/common/vowels.ts
+  var vowels = ["a", "e", "i", "o", "u"];
+  var aOrAn = /* @__PURE__ */ __name((word) => {
+    return `${vowels.includes(word[0].toLowerCase()) ? "an" : "a"} ${word}`;
+  }, "aOrAn");
+
+  // src/constraints/util/typedArray.ts
+  var TypedArrays = {
+    Int8Array: (x2) => x2 instanceof Int8Array,
+    Uint8Array: (x2) => x2 instanceof Uint8Array,
+    Uint8ClampedArray: (x2) => x2 instanceof Uint8ClampedArray,
+    Int16Array: (x2) => x2 instanceof Int16Array,
+    Uint16Array: (x2) => x2 instanceof Uint16Array,
+    Int32Array: (x2) => x2 instanceof Int32Array,
+    Uint32Array: (x2) => x2 instanceof Uint32Array,
+    Float32Array: (x2) => x2 instanceof Float32Array,
+    Float64Array: (x2) => x2 instanceof Float64Array,
+    BigInt64Array: (x2) => x2 instanceof BigInt64Array,
+    BigUint64Array: (x2) => x2 instanceof BigUint64Array,
+    TypedArray: (x2) => ArrayBuffer.isView(x2) && !(x2 instanceof DataView)
+  };
+
+  // src/validators/TypedArrayValidator.ts
+  var TypedArrayValidator = class extends BaseValidator {
+    constructor(type, constraints = []) {
+      super(constraints);
+      this.type = type;
+    }
+    byteLengthLessThan(length) {
+      return this.addConstraint(typedArrayByteLengthLessThan(length));
+    }
+    byteLengthLessThanOrEqual(length) {
+      return this.addConstraint(typedArrayByteLengthLessThanOrEqual(length));
+    }
+    byteLengthGreaterThan(length) {
+      return this.addConstraint(typedArrayByteLengthGreaterThan(length));
+    }
+    byteLengthGreaterThanOrEqual(length) {
+      return this.addConstraint(typedArrayByteLengthGreaterThanOrEqual(length));
+    }
+    byteLengthEqual(length) {
+      return this.addConstraint(typedArrayByteLengthEqual(length));
+    }
+    byteLengthNotEqual(length) {
+      return this.addConstraint(typedArrayByteLengthNotEqual(length));
+    }
+    byteLengthRange(start, endBefore) {
+      return this.addConstraint(typedArrayByteLengthRange(start, endBefore));
+    }
+    byteLengthRangeInclusive(startAt, endAt) {
+      return this.addConstraint(typedArrayByteLengthRangeInclusive(startAt, endAt));
+    }
+    byteLengthRangeExclusive(startAfter, endBefore) {
+      return this.addConstraint(typedArrayByteLengthRangeExclusive(startAfter, endBefore));
+    }
+    lengthLessThan(length) {
+      return this.addConstraint(typedArrayLengthLessThan(length));
+    }
+    lengthLessThanOrEqual(length) {
+      return this.addConstraint(typedArrayLengthLessThanOrEqual(length));
+    }
+    lengthGreaterThan(length) {
+      return this.addConstraint(typedArrayLengthGreaterThan(length));
+    }
+    lengthGreaterThanOrEqual(length) {
+      return this.addConstraint(typedArrayLengthGreaterThanOrEqual(length));
+    }
+    lengthEqual(length) {
+      return this.addConstraint(typedArrayLengthEqual(length));
+    }
+    lengthNotEqual(length) {
+      return this.addConstraint(typedArrayLengthNotEqual(length));
+    }
+    lengthRange(start, endBefore) {
+      return this.addConstraint(typedArrayLengthRange(start, endBefore));
+    }
+    lengthRangeInclusive(startAt, endAt) {
+      return this.addConstraint(typedArrayLengthRangeInclusive(startAt, endAt));
+    }
+    lengthRangeExclusive(startAfter, endBefore) {
+      return this.addConstraint(typedArrayLengthRangeExclusive(startAfter, endBefore));
+    }
+    clone() {
+      return Reflect.construct(this.constructor, [this.type, this.constraints]);
+    }
+    handle(value) {
+      return TypedArrays[this.type](value) ? Result.ok(value) : Result.err(new ValidationError("s.typedArray", `Expected ${aOrAn(this.type)}`, value));
+    }
+  };
+  __name(TypedArrayValidator, "TypedArrayValidator");
+
+  // src/lib/Shapes.ts
+  var Shapes = class {
+    get string() {
+      return new StringValidator();
+    }
+    get number() {
+      return new NumberValidator();
+    }
+    get bigint() {
+      return new BigIntValidator();
+    }
+    get boolean() {
+      return new BooleanValidator();
+    }
+    get date() {
+      return new DateValidator();
+    }
+    object(shape) {
+      return new ObjectValidator(shape);
+    }
+    get undefined() {
+      return this.literal(void 0);
+    }
+    get null() {
+      return this.literal(null);
+    }
+    get nullish() {
+      return new NullishValidator();
+    }
+    get any() {
+      return new PassthroughValidator();
+    }
+    get unknown() {
+      return new PassthroughValidator();
+    }
+    get never() {
+      return new NeverValidator();
+    }
+    enum(...values) {
+      return this.union(...values.map((value) => this.literal(value)));
+    }
+    nativeEnum(enumShape) {
+      return new NativeEnumValidator(enumShape);
+    }
+    literal(value) {
+      if (value instanceof Date)
+        return this.date.equal(value);
+      return new LiteralValidator(value);
+    }
+    instance(expected) {
+      return new InstanceValidator(expected);
+    }
+    union(...validators) {
+      return new UnionValidator(validators);
+    }
+    array(validator) {
+      return new ArrayValidator(validator);
+    }
+    typedArray(type = "TypedArray") {
+      return new TypedArrayValidator(type);
+    }
+    get int8Array() {
+      return this.typedArray("Int8Array");
+    }
+    get uint8Array() {
+      return this.typedArray("Uint8Array");
+    }
+    get uint8ClampedArray() {
+      return this.typedArray("Uint8ClampedArray");
+    }
+    get int16Array() {
+      return this.typedArray("Int16Array");
+    }
+    get uint16Array() {
+      return this.typedArray("Uint16Array");
+    }
+    get int32Array() {
+      return this.typedArray("Int32Array");
+    }
+    get uint32Array() {
+      return this.typedArray("Uint32Array");
+    }
+    get float32Array() {
+      return this.typedArray("Float32Array");
+    }
+    get float64Array() {
+      return this.typedArray("Float64Array");
+    }
+    get bigInt64Array() {
+      return this.typedArray("BigInt64Array");
+    }
+    get bigUint64Array() {
+      return this.typedArray("BigUint64Array");
+    }
+    tuple(validators) {
+      return new TupleValidator(validators);
+    }
+    set(validator) {
+      return new SetValidator(validator);
+    }
+    record(validator) {
+      return new RecordValidator(validator);
+    }
+    map(keyValidator, valueValidator) {
+      return new MapValidator(keyValidator, valueValidator);
+    }
+    lazy(validator) {
+      return new LazyValidator(validator);
+    }
+  };
+  __name(Shapes, "Shapes");
+
+  // src/index.ts
+  var s3 = new Shapes();
+
+  exports.BaseError = BaseError;
+  exports.CombinedError = CombinedError;
+  exports.CombinedPropertyError = CombinedPropertyError;
+  exports.ExpectedConstraintError = ExpectedConstraintError;
+  exports.ExpectedValidationError = ExpectedValidationError;
+  exports.MissingPropertyError = MissingPropertyError;
+  exports.MultiplePossibilitiesConstraintError = MultiplePossibilitiesConstraintError;
+  exports.Result = Result;
+  exports.UnknownEnumValueError = UnknownEnumValueError;
+  exports.UnknownPropertyError = UnknownPropertyError;
+  exports.ValidationError = ValidationError;
+  exports.customInspectSymbol = customInspectSymbol;
+  exports.customInspectSymbolStackLess = customInspectSymbolStackLess;
+  exports.getGlobalValidationEnabled = getGlobalValidationEnabled;
+  exports.s = s3;
+  exports.setGlobalValidationEnabled = setGlobalValidationEnabled;
+
+  return exports;
+
+})({});
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.global.js.map
\ No newline at end of file