diff options
Diffstat (limited to 'node_modules/@sapphire/shapeshift')
| -rw-r--r-- | node_modules/@sapphire/shapeshift/CHANGELOG.md | 292 | ||||
| -rw-r--r-- | node_modules/@sapphire/shapeshift/LICENSE.md | 24 | ||||
| -rw-r--r-- | node_modules/@sapphire/shapeshift/README.md | 934 | ||||
| -rw-r--r-- | node_modules/@sapphire/shapeshift/dist/index.d.ts | 715 | ||||
| -rw-r--r-- | node_modules/@sapphire/shapeshift/dist/index.global.js | 4174 | ||||
| -rw-r--r-- | node_modules/@sapphire/shapeshift/dist/index.global.js.map | 1 | ||||
| -rw-r--r-- | node_modules/@sapphire/shapeshift/dist/index.js | 2242 | ||||
| -rw-r--r-- | node_modules/@sapphire/shapeshift/dist/index.js.map | 1 | ||||
| -rw-r--r-- | node_modules/@sapphire/shapeshift/dist/index.mjs | 2219 | ||||
| -rw-r--r-- | node_modules/@sapphire/shapeshift/dist/index.mjs.map | 1 | ||||
| -rw-r--r-- | node_modules/@sapphire/shapeshift/package.json | 125 |
11 files changed, 10728 insertions, 0 deletions
diff --git a/node_modules/@sapphire/shapeshift/CHANGELOG.md b/node_modules/@sapphire/shapeshift/CHANGELOG.md new file mode 100644 index 0000000..1d4b4a3 --- /dev/null +++ b/node_modules/@sapphire/shapeshift/CHANGELOG.md @@ -0,0 +1,292 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +# [3.9.2](https://github.com/sapphiredev/shapeshift/compare/v3.9.1...v3.9.2) - (2023-06-04) + +## π Bug Fixes + +- **arrayvalidator:** Fixed runaway type instantiation with TypeScript >=5.1 (#275) ([f59d901](https://github.com/sapphiredev/shapeshift/commit/f59d90112181e6625230c28e6a4f0f065ced6344)) + +# [3.9.1](https://github.com/sapphiredev/shapeshift/compare/v3.9.0...v3.9.1) - (2023-06-02) + +## π Bug Fixes + +- **types:** Move the `types` condition to the front (#273) ([5a3e202](https://github.com/sapphiredev/shapeshift/commit/5a3e202e9ceafb3d330a568e93c060dd5aac1dde)) + +# [3.9.0](https://github.com/sapphiredev/shapeshift/compare/v3.8.2...v3.9.0) - (2023-05-09) + +## π Bug Fixes + +- Resolve minor grammar mistake (#260) ([62df609](https://github.com/sapphiredev/shapeshift/commit/62df6094845ffa118aa93ea3c5f47f81f1c5d99f)) + +## π Features + +- Add BaseValidator.describe (#267) ([d9e1a2d](https://github.com/sapphiredev/shapeshift/commit/d9e1a2d2f3c5e6378f0025becf8497138ee6d97c)) + +# [3.8.2](https://github.com/sapphiredev/shapeshift/compare/v3.8.1...v3.8.2) - (2023-04-02) + +## π Bug Fixes + +- ***:** TypeScript 5.x compatibility (#253) ([eba2a88](https://github.com/sapphiredev/shapeshift/commit/eba2a88b91fb6631f431313753299ec7a70cf6ce)) +- Remove `node:` prefix (#249) ([af766b5](https://github.com/sapphiredev/shapeshift/commit/af766b504c1013f3cd24f7bf803ac9ff7442a8d7)) + +# [3.8.1](https://github.com/sapphiredev/shapeshift/compare/v3.8.0...v3.8.1) - (2022-12-15) + +## π Bug Fixes + +- Fixed lodash esm import (#230) ([63def7b](https://github.com/sapphiredev/shapeshift/commit/63def7bcec6319b3792093945ba7ba9f871ced6f)) + +# [3.8.0](https://github.com/sapphiredev/shapeshift/compare/v3.7.1...v3.8.0) - (2022-12-11) + +## π Refactor + +- Remove `NonNullObject` (#227) ([04d3934](https://github.com/sapphiredev/shapeshift/commit/04d39343f55a4e1571f54870a84d8b95447bd682)) + +## π Features + +- Add `when` constraint (#223) ([8eade90](https://github.com/sapphiredev/shapeshift/commit/8eade90cd4c02b80746ecdcdc612829d7f765178)) + +# [3.7.1](https://github.com/sapphiredev/shapeshift/compare/v3.7.0...v3.7.1) - (2022-11-27) + +## π Bug Fixes + +- Fixed "jump to definition" for `undefinedToOptional` going to wrong symbol (#226) ([6aab6d0](https://github.com/sapphiredev/shapeshift/commit/6aab6d01450fd7abbeaa95e91fb58568240e02ff)) + +## π Documentation + +- Add @legendhimslef as a contributor ([499522a](https://github.com/sapphiredev/shapeshift/commit/499522a782c3ecd4df80978d0811df1a75d08212)) + +# [3.7.0](https://github.com/sapphiredev/shapeshift/compare/v3.6.0...v3.7.0) - (2022-10-02) + +## π Documentation + +- Add phone in readme (#203) ([4ec9b7a](https://github.com/sapphiredev/shapeshift/commit/4ec9b7ab85124d84b3404cb548b17b9221a716c5)) +- Add RealShadowNova as a contributor for tool (#185) ([6dfc442](https://github.com/sapphiredev/shapeshift/commit/6dfc442af6ef26d6bbca39078eca5727257b6dab)) + +## π Features + +- Add `s.string.phone` (#202) ([7d122d5](https://github.com/sapphiredev/shapeshift/commit/7d122d5dc0eaa63c639b9cde1514e63566a681bd)) + +# [3.6.0](https://github.com/sapphiredev/shapeshift/compare/v3.5.1...v3.6.0) - (2022-08-29) + +## π Bug Fixes + +- Typescript 4.8 compatibility (#179) ([2281535](https://github.com/sapphiredev/shapeshift/commit/2281535f7589a987510828e46bf66accc8393c34)) + +## π Features + +- Add `Validator#is` (#183) ([5114f95](https://github.com/sapphiredev/shapeshift/commit/5114f9516e5406cd1ca4a7ceb5ea5761158af1c6)) + +# [3.5.1](https://github.com/sapphiredev/shapeshift/compare/v3.5.0...v3.5.1) - (2022-07-17) + +## π Bug Fixes + +- Fast deep equal import (#155) ([5ce8ff6](https://github.com/sapphiredev/shapeshift/commit/5ce8ff6803b70624af07c3e406bc1cdc9e3cdafe)) + +# [3.5.0](https://github.com/sapphiredev/shapeshift/compare/v3.4.1...v3.5.0) - (2022-07-10) + +## π Refactor + +- Port net module (#149) ([5f26e32](https://github.com/sapphiredev/shapeshift/commit/5f26e32b0f87d2b100ca13471d5835c0067ddee8)) + +## π Bug Fixes + +- Ensure browser compatibility (#150) ([92d05d8](https://github.com/sapphiredev/shapeshift/commit/92d05d83c1fbab53f98f61219fb01d49fc031bae)) +- Fixed `s.array` type inference (#153) ([a5948dc](https://github.com/sapphiredev/shapeshift/commit/a5948dc67ce6a0ea73986d32084898a4ce0b9c3a)) +- Fixed `shape#array` types (#146) ([43016a0](https://github.com/sapphiredev/shapeshift/commit/43016a025b04a676d906758ed065d26a17231888)) + +## π Features + +- Lazy validator (#147) ([807666e](https://github.com/sapphiredev/shapeshift/commit/807666ef537c84d2e0f8bd9f4ce1a8060bfb3fb5)) +- Reshape finally (#148) ([d3751f6](https://github.com/sapphiredev/shapeshift/commit/d3751f6d3d99f415d797369f98158f932371e02c)) +- **arrays:** Add unique (#141) ([ad7af34](https://github.com/sapphiredev/shapeshift/commit/ad7af34eb811541253150b7ff0b58a6bd7200796)) + +# [3.4.1](https://github.com/sapphiredev/shapeshift/compare/v3.4.0...v3.4.1) - (2022-07-03) + +## π Refactor + +- Move all type utilities to one file (#139) ([61cab3d](https://github.com/sapphiredev/shapeshift/commit/61cab3d0e486d9dc74c8f6160ff8c75c91b595b2)) + +## π Bug Fixes + +- Return array-validator from length* methods (#140) ([75b1f9a](https://github.com/sapphiredev/shapeshift/commit/75b1f9a6efffb6c27dcfd48eb4ec6269a3614633)) + +## π§ͺ Testing + +- Typechecking for tests (#145) ([273cdc8](https://github.com/sapphiredev/shapeshift/commit/273cdc82c1cf65ba4111ca6e70b050e02cbdf485)) + +# [3.4.0](https://github.com/sapphiredev/shapeshift/compare/v3.3.2...v3.4.0) - (2022-06-29) + +## π Features + +- Add `required` in object validation (#137) ([928f7be](https://github.com/sapphiredev/shapeshift/commit/928f7beb5e727b47868e9e46f2191f2def228080)) + +# [3.3.2](https://github.com/sapphiredev/shapeshift/compare/v3.3.1...v3.3.2) - (2022-06-26) + +## π Bug Fixes + +- Make keys optional in object parsing (#134) ([57a3719](https://github.com/sapphiredev/shapeshift/commit/57a37193d64399aae1431b041012d582e8defecf)) + +# [3.3.1](https://github.com/sapphiredev/shapeshift/compare/v3.3.0...v3.3.1) - (2022-06-22) + +## π Bug Fixes + +- Add generic type to parse (#133) ([90c91aa](https://github.com/sapphiredev/shapeshift/commit/90c91aad572d51a2bfbd1ed32a51e1d4201c5d4a)) + +# [3.3.0](https://github.com/sapphiredev/shapeshift/compare/v3.2.0...v3.3.0) - (2022-06-19) + +## π Bug Fixes + +- Compile for es2020 instead of es2021 (#128) ([051344d](https://github.com/sapphiredev/shapeshift/commit/051344debe1cf423713d7fc64b8908353348f301)) + +## π Features + +- Allow passing functions in `setValidationEnabled` (#131) ([e1991cf](https://github.com/sapphiredev/shapeshift/commit/e1991cfef1ffe92f9167d11d7f2ded65379df8d2)) + +## π§ͺ Testing + +- Migrate to vitest (#126) ([4d80969](https://github.com/sapphiredev/shapeshift/commit/4d80969b714c39768499569456405a73c1444da8)) + +# [3.2.0](https://github.com/sapphiredev/shapeshift/compare/v3.1.0...v3.2.0) - (2022-06-11) + +## π Features + +- Add disabling of validators (#125) ([e17af95](https://github.com/sapphiredev/shapeshift/commit/e17af95d697be62796c57d03385b0c74b9d2d580)) + +# [3.1.0](https://github.com/sapphiredev/shapeshift/compare/v3.0.0...v3.1.0) - (2022-06-04) + +## π Bug Fixes + +- **ObjectValidator:** Fix #121 (#122) ([ecfad7e](https://github.com/sapphiredev/shapeshift/commit/ecfad7ec2cdd9e0cee0b3e227e55a91b28c29c30)) + +## π Documentation + +- **readme:** Clarify the difference between validations and schemas and add table of contents (#108) ([dc492a3](https://github.com/sapphiredev/shapeshift/commit/dc492a395349cc5bc680f313146127ea510b4ada)) + +## π Features + +- **StringValidator:** Add date string checks (#106) ([1b72907](https://github.com/sapphiredev/shapeshift/commit/1b729078be32a88aeddf574c9cff3098990d4f94)) + +# [3.0.0](https://github.com/sapphiredev/shapeshift/compare/v2.2.0...v3.0.0) - (2022-05-06) + +## π Performance + +- Speed up object validation a LOT (#101) ([817278e](https://github.com/sapphiredev/shapeshift/commit/817278e6a3ac128ca342e5ae1737f40b98788c37)) + +## π Bug Fixes + +- Expand method names (#100) ([741490f](https://github.com/sapphiredev/shapeshift/commit/741490fb6907f618fa25fe53808f7dcb5a59a96c))} + + ### π₯ Breaking Changes: + - `date.eq` has been renamed to `date.equal` + - `string.lengthLt` has been renamed to `string.lengthLessThan` + - `string.lengthLe` has been renamed to `string.lengthLessThanOrEqual` + - `string.lengthGt` has been renamed to `string.lengthGreaterThan` + - `string.lengthGe` has been renamed to `string.lengthGreaterThanOrEqual` + - `string.lengthEq` has been renamed to `string.lengthEqual` + - `string.lengthNe` has been renamed to `string.lengthNotEqual` + - `number.gt` has been renamed to `number.greaterThan` + - `number.ge` has been renamed to `number.greaterThanOrEqual` + - `number.lt` has been renamed to `number.lessThan` + - `number.le` has been renamed to `number.lessThanOrEqual` + - `number.eq` has been renamed to `number.equal` + - `number.ne` has been renamed to `number.notEqual` + - `bigint.gt` has been renamed to `bigint.greaterThan` + - `bigint.ge` has been renamed to `bigint.greaterThanOrEqual` + - `bigint.lt` has been renamed to `bigint.lessThan` + - `bigint.le` has been renamed to `bigint.lessThanOrEqual` + - `bigint.eq` has been renamed to `bigint.equal` + - `bigint.ne` has been renamed to `bigint.notEqual` + - `boolean.eq` has been renamed to `boolean.equal` + - `boolean.ne` has been renamed to `boolean.notEqual` + - `array.lengthLt` has been renamed to `array.lengthLessThan` + - `array.lengthLe` has been renamed to `array.lengthLessThanOrEqual` + - `array.lengthGt` has been renamed to `array.lengthGreaterThan` + - `array.lengthGe` has been renamed to `array.lengthGreaterThanOrEqual` + - `array.lengthEq` has been renamed to `array.lengthEqual` + - `array.lengthNe` has been renamed to `array.lengthNotEqual` + - `typedArray.lengthLt` has been renamed to `typedArray.lengthLessThan` + - `typedArray.lengthLe` has been renamed to `typedArray.lengthLessThanOrEqual` + - `typedArray.lengthGt` has been renamed to `typedArray.lengthGreaterThan` + - `typedArray.lengthGe` has been renamed to `typedArray.lengthGreaterThanOrEqual` + - `typedArray.lengthEq` has been renamed to `typedArray.lengthEqual` + - `typedArray.lengthNe` has been renamed to `typedArray.lengthNotEqual` + - `typedArray.byteLengthLt` has been renamed to `typedArray.byteLengthLessThan` + - `typedArray.byteLengthLe` has been renamed to `typedArray.byteLengthLessThanOrEqual` + - `typedArray.byteLengthGt` has been renamed to `typedArray.byteLengthGreaterThan` + - `typedArray.byteLengthGe` has been renamed to `typedArray.byteLengthGreaterThanOrEqual` + - `typedArray.byteLengthEq` has been renamed to `typedArray.byteLengthEqual` + - `typedArray.byteLengthNe` has been renamed to `typedArray.byteLengthNotEqual` + +- **ObjectValidator:** Don't run validation on arrays (#99) ([c83b3d0](https://github.com/sapphiredev/shapeshift/commit/c83b3d03a201d38cc230d9c831ca1d9b66ca533b)) + +## π Features + +- Add 2 utility types inspired by yup and co (#102) ([2fef902](https://github.com/sapphiredev/shapeshift/commit/2fef9026c30f2f1825aa55511d0ab088a3dd13ab)) + +# [2.2.0](https://github.com/sapphiredev/shapeshift/compare/v2.0.0...v2.2.0) - (2022-04-29) + +## Bug Fixes + +- Ensure `BaseError` is exported as value (#95) ([335d799](https://github.com/sapphiredev/shapeshift/commit/335d799ef7a8c1a19a12e3eeec07e6d210db113d)) + +## Documentation + +- **readme:** Add todo notice for `reshape` and `function` validations (#75) ([d5f16f6](https://github.com/sapphiredev/shapeshift/commit/d5f16f615de83503187dc834c6245fafbf138f5e)) + +## Features + +- Add Typed Array (#78) ([ca5ea5f](https://github.com/sapphiredev/shapeshift/commit/ca5ea5f568084bd5d3aa004911d4ea64329e1a89)) + +## Performance + +- Optimize `NativeEnum` (#79) ([e9ae280](https://github.com/sapphiredev/shapeshift/commit/e9ae280f73e9ea08239bd8bd22165fe0b2178f82)) + +# [@sapphire/shapeshift@2.1.0](https://github.com/sapphiredev/shapeshift/compare/v2.0.0...@sapphire/shapeshift@2.1.0) - (2022-04-24) + +## Documentation + +- **readme:** Add todo notice for `reshape` and `function` validations (#75) ([d5f16f6](https://github.com/sapphiredev/shapeshift/commit/d5f16f615de83503187dc834c6245fafbf138f5e)) + +## Performance + +- Optimize `NativeEnum` (#79) ([e9ae280](https://github.com/sapphiredev/shapeshift/commit/e9ae280f73e9ea08239bd8bd22165fe0b2178f82)) + +## [2.0.0](https://github.com/sapphiredev/shapeshift/compare/v1.0.0...v2.0.0) (2022-03-13) + +### Features + +- add `default` ([#25](https://github.com/sapphiredev/shapeshift/issues/25)) ([378c51f](https://github.com/sapphiredev/shapeshift/commit/378c51fb4ba2c501fd782387169db888d6bfe662)) +- add bigint methods ([#32](https://github.com/sapphiredev/shapeshift/issues/32)) ([4c444c1](https://github.com/sapphiredev/shapeshift/commit/4c444c15657c4610b99481b6dec9812bd136d72b)) +- add MapValidator ([#21](https://github.com/sapphiredev/shapeshift/issues/21)) ([c4d1258](https://github.com/sapphiredev/shapeshift/commit/c4d12586762d446b858454077b66635d9d11e2d6)) +- add NativeEnum validator ([#54](https://github.com/sapphiredev/shapeshift/issues/54)) ([7359042](https://github.com/sapphiredev/shapeshift/commit/7359042843d1119f396ac2c038aaff89dbd90c8e)) +- add RecordValidator ([#20](https://github.com/sapphiredev/shapeshift/issues/20)) ([8727427](https://github.com/sapphiredev/shapeshift/commit/8727427be4656792eebcdc5bddf6bcd61bc7e846)) +- add remaining string validations ([#38](https://github.com/sapphiredev/shapeshift/issues/38)) ([1c2fd7b](https://github.com/sapphiredev/shapeshift/commit/1c2fd7bbb20463f09ac461b697c312bec6ae9195)) +- add tuple ([#39](https://github.com/sapphiredev/shapeshift/issues/39)) ([b7704bf](https://github.com/sapphiredev/shapeshift/commit/b7704bf87cf5225021408cf4a6b9ceff8cba25b3)) +- added number transformers ([#17](https://github.com/sapphiredev/shapeshift/issues/17)) ([89a8ddd](https://github.com/sapphiredev/shapeshift/commit/89a8ddd8583774e68c43260c28ee1589ef44516c)) +- allow the use of module: NodeNext ([#55](https://github.com/sapphiredev/shapeshift/issues/55)) ([e6827c5](https://github.com/sapphiredev/shapeshift/commit/e6827c5a12b6a2803a137b71fe4c21bd1c35034b)) +- **array:** add array length Comparators ([#40](https://github.com/sapphiredev/shapeshift/issues/40)) ([1e564c2](https://github.com/sapphiredev/shapeshift/commit/1e564c204b6c9b0a798b3121d31dd4cc99165f60)) +- **Array:** generate tuple types with given length ([#52](https://github.com/sapphiredev/shapeshift/issues/52)) ([793648b](https://github.com/sapphiredev/shapeshift/commit/793648b4cde1f72c5b735ceebb0c48272179be06)) +- **ArrayValidator:** add length ranges ([#53](https://github.com/sapphiredev/shapeshift/issues/53)) ([e431d62](https://github.com/sapphiredev/shapeshift/commit/e431d6218b86fc1480fce14c4466cb36567cad2f)) +- display the property that errored ([#35](https://github.com/sapphiredev/shapeshift/issues/35)) ([fe188b0](https://github.com/sapphiredev/shapeshift/commit/fe188b0d17eeaa5f73b08085562903e23e91717c)) +- improve how errors are returned ([#29](https://github.com/sapphiredev/shapeshift/issues/29)) ([8bc7669](https://github.com/sapphiredev/shapeshift/commit/8bc7669a1a66a10449b321cc4447e411383977d9)) +- **s.object:** add passthrough ([#66](https://github.com/sapphiredev/shapeshift/issues/66)) ([ee9f6f3](https://github.com/sapphiredev/shapeshift/commit/ee9f6f367e513c0120a04cfafe05057c7907c327)) + +### Bug Fixes + +- copy/paste error and `ge` ([#22](https://github.com/sapphiredev/shapeshift/issues/22)) ([fe6505f](https://github.com/sapphiredev/shapeshift/commit/fe6505f8e698bcaf9f8024b2d8f012559827cbb0)) +- fix union type and add test ([#41](https://github.com/sapphiredev/shapeshift/issues/41)) ([fbcf8a9](https://github.com/sapphiredev/shapeshift/commit/fbcf8a9c617c16b33fdddb0a44aa0fe506164fd3)) +- **s.union:** fix union overrides ([#62](https://github.com/sapphiredev/shapeshift/issues/62)) ([56e9b19](https://github.com/sapphiredev/shapeshift/commit/56e9b1947d9b2b129dbed374671114b2242e6d35)) + +## 1.0.0 (2022-01-16) + +### Features + +- added more primitives ([#2](https://github.com/sapphiredev/shapeshift/issues/2)) ([16af17b](https://github.com/sapphiredev/shapeshift/commit/16af17b5d9ee40dce284ee120e0b099f7b2cc0b8)) +- added more things ([7c73d82](https://github.com/sapphiredev/shapeshift/commit/7c73d82cf3740d5b2d4eebcac7767da9d3562437)) +- added ObjectValidator ([#3](https://github.com/sapphiredev/shapeshift/issues/3)) ([abe7ead](https://github.com/sapphiredev/shapeshift/commit/abe7eaddee981ef485713ff5e7b7f32ff97c645b)) + +### Bug Fixes + +- resolved install error ([a5abe13](https://github.com/sapphiredev/shapeshift/commit/a5abe1362bb6d9ce6d6471bffa47fe8983b0d1a4)) diff --git a/node_modules/@sapphire/shapeshift/LICENSE.md b/node_modules/@sapphire/shapeshift/LICENSE.md new file mode 100644 index 0000000..95a4396 --- /dev/null +++ b/node_modules/@sapphire/shapeshift/LICENSE.md @@ -0,0 +1,24 @@ +# The MIT License (MIT) + +Copyright Β© `2021` `The Sapphire Community and its contributors` + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the βSoftwareβ), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED βAS ISβ, WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/@sapphire/shapeshift/README.md b/node_modules/@sapphire/shapeshift/README.md new file mode 100644 index 0000000..c9f113f --- /dev/null +++ b/node_modules/@sapphire/shapeshift/README.md @@ -0,0 +1,934 @@ +<div align="center"> + + + +# @sapphire/shapeshift + +**Shapeshift** + +Blazing fast input validation and transformation β‘ + +[](https://github.com/sapphiredev/shapeshift/blob/main/LICENSE.md) +[](https://codecov.io/gh/sapphiredev/shapeshift) +[](https://www.npmjs.com/package/@sapphire/shapeshift) + +</div> + +## Table of Contents + +- [@sapphire/shapeshift](#sapphireshapeshift) + - [Table of Contents](#table-of-contents) + - [Description](#description) + - [Features](#features) + - [Usage](#usage) + - [Basic usage](#basic-usage) + - [Defining validations](#defining-validations) + - [Primitives](#primitives) + - [Literals](#literals) + - [Strings](#strings) + - [Numbers](#numbers) + - [BigInts](#bigints) + - [Booleans](#booleans) + - [Arrays](#arrays) + - [Tuples](#tuples) + - [Unions](#unions) + - [Enums](#enums) + - [Maps](#maps) + - [Sets](#sets) + - [Instances](#instances) + - [Records](#records) + - [Functions // TODO](#functions--todo) + - [TypedArray](#typedarray) + - [Defining schemas (objects)](#defining-schemas-objects) + - [Utility types for TypeScript](#utility-types-for-typescript) + - [Extracting an interface from a schema](#extracting-an-interface-from-a-schema) + - [Defining the structure of a schema through an interface](#defining-the-structure-of-a-schema-through-an-interface) + - [`.extend`:](#extend) + - [`.pick` / `.omit`:](#pick--omit) + - [`.partial`](#partial) + - [`.required`](#required) + - [Handling unrecognized keys](#handling-unrecognized-keys) + - [`.strict`](#strict) + - [`.ignore`](#ignore) + - [`.passthrough`](#passthrough) + - [BaseValidator: methods and properties](#basevalidator-methods-and-properties) + - [`.run`](#rundata-unknown-resultt-error-given-a-validation-you-can-call-this-method-to-check-whether-or-not-the) + - [`.parse`](#parsedata-unknown-t-given-a-validations-you-can-call-this-method-to-check-whether-or-not-the-input-is-valid) + - [`.transform`](#transformrvalue-t--r-nopvalidatorr-adds-a-constraint-that-modifies-the-input) + - [`.reshape`](#reshapervalue-t--resultr-error--iconstraint-nopvalidatorr-adds-a-constraint-able-to-both-validate) + - [`.default`](#defaultvalue-t----t-transform-undefined-into-the-given-value-or-the-callbacks-returned-value) + - [`.optional`](#optional-a-convenience-method-that-returns-a-union-of-the-type-with-sundefined) + - [`.nullable`](#nullable-a-convenience-method-that-returns-a-union-of-the-type-with-snullable) + - [`.nullish`](#nullish-a-convenience-method-that-returns-a-union-of-the-type-with-snullish) + - [`.array`](#array-a-convenience-method-that-returns-an-arrayvalidator-with-the-type) + - [`.or`](#or-a-convenience-method-that-returns-an-unionvalidator-with-the-type-this-method-is-also-overridden-in) + - [`.when`](#when-adjust-the-schema-based-on-a-sibling-or-sinbling-children-fields) + - [Available options for providing `is`](#available-options-for-providing-is) + - [Resolving of the `key` (first) parameter](#resolving-of-the-key-first-parameter) + - [Examples](#examples) + - [Enabling and disabling validation](#enabling-and-disabling-validation) + - [Buy us some doughnuts](#buy-us-some-doughnuts) + - [Contributors](#contributors) + +## Description + +[Back to top][toc] + +A very fast and lightweight input validation and transformation library for JavaScript. + +> **Note**: Shapeshift requires Node.js v14.0.0 or higher to work. + +## Features + +[Back to top][toc] + +- TypeScript friendly +- Offers CJS, ESM and UMD builds +- API similar to [`zod`] +- Faster than β‘ + +## Usage + +[Back to top][toc] + +**_For complete usages, please dive into our [documentation]_** + +### Basic usage + +[Back to top][toc] + +Creating a simple string validation + +```typescript +import { s } from '@sapphire/shapeshift'; + +const myStringValidation = s.string; + +// Parse +myStringValidation.parse('sapphire'); // => returns 'sapphire' +myStringValidation.parse(12); // throws ValidationError +``` + +Creating an object schema + +```typescript +import { s } from '@sapphire/shapeshift'; + +const user = s.object({ + username: s.string +}); + +user.parse({ username: 'Sapphire' }); +``` + +### Defining validations + +[Back to top][toc] + +#### Primitives + +[Back to top][toc] + +```typescript +import { s } from '@sapphire/shapeshift'; + +// Primitives +s.string; +s.number; +s.bigint; +s.boolean; +s.date; + +// Empty Types +s.undefined; +s.null; +s.nullish; // Accepts undefined | null + +// Catch-all Types +s.any; +s.unknown; + +// Never Type +s.never; +``` + +#### Literals + +[Back to top][toc] + +```typescript +s.literal('sapphire'); +s.literal(12); +s.literal(420n); +s.literal(true); +s.literal(new Date(1639278160000)); // s.date.equal(1639278160000); +``` + +#### Strings + +[Back to top][toc] + +Shapeshift includes a handful of string-specific validations: + +```typescript +s.string.lengthLessThan(5); +s.string.lengthLessThanOrEqual(5); +s.string.lengthGreaterThan(5); +s.string.lengthGreaterThanOrEqual(5); +s.string.lengthEqual(5); +s.string.lengthNotEqual(5); +s.string.email; +s.string.url(); +s.string.uuid(); +s.string.regex(regex); +s.string.ip(); +s.string.ipv4; +s.string.ipv6; +s.string.phone(); +``` + +#### Numbers + +[Back to top][toc] + +Shapeshift includes a handful of number-specific validations: + +```typescript +s.number.greaterThan(5); // > 5 +s.number.greaterThanOrEqual(5); // >= 5 +s.number.lessThan(5); // < 5 +s.number.lessThanOrEqual(5); // <= 5 +s.number.equal(5); // === 5 +s.number.notEqual(5); // !== 5 + +s.number.equal(NaN); // special case: Number.isNaN +s.number.notEqual(NaN); // special case: !Number.isNaN + +s.number.int; // value must be an integer +s.number.safeInt; // value must be a safe integer +s.number.finite; // value must be finite + +s.number.positive; // .greaterThanOrEqual(0) +s.number.negative; // .lessThan(0) + +s.number.divisibleBy(5); // Divisible by 5 +``` + +And transformations: + +```typescript +s.number.abs; // Transforms the number to an absolute number +s.number.sign; // Gets the number's sign + +s.number.trunc; // Transforms the number to the result of `Math.trunc` +s.number.floor; // Transforms the number to the result of `Math.floor` +s.number.fround; // Transforms the number to the result of `Math.fround` +s.number.round; // Transforms the number to the result of `Math.round` +s.number.ceil; // Transforms the number to the result of `Math.ceil` +``` + +#### BigInts + +[Back to top][toc] + +Shapeshift includes a handful of number-specific validations: + +```typescript +s.bigint.greaterThan(5n); // > 5n +s.bigint.greaterThanOrEqual(5n); // >= 5n +s.bigint.lessThan(5n); // < 5n +s.bigint.lessThanOrEqual(5n); // <= 5n +s.bigint.equal(5n); // === 5n +s.bigint.notEqual(5n); // !== 5n + +s.bigint.positive; // .greaterThanOrEqual(0n) +s.bigint.negative; // .lessThan(0n) + +s.bigint.divisibleBy(5n); // Divisible by 5n +``` + +And transformations: + +```typescript +s.bigint.abs; // Transforms the bigint to an absolute bigint + +s.bigint.intN(5); // Clamps to a bigint to a signed bigint with 5 digits, see BigInt.asIntN +s.bigint.uintN(5); // Clamps to a bigint to an unsigned bigint with 5 digits, see BigInt.asUintN +``` + +#### Booleans + +[Back to top][toc] + +Shapeshift includes a few boolean-specific validations: + +```typescript +s.boolean.true; // value must be true +s.boolean.false; // value must be false + +s.boolean.equal(true); // s.boolean.true +s.boolean.equal(false); // s.boolean.false + +s.boolean.notEqual(true); // s.boolean.false +s.boolean.notEqual(false); // s.boolean.true +``` + +#### Arrays + +[Back to top][toc] + +```typescript +const stringArray = s.array(s.string); +const stringArray = s.string.array; +``` + +Shapeshift includes a handful of array-specific validations: + +```typescript +s.string.array.lengthLessThan(5); // Must have less than 5 elements +s.string.array.lengthLessThanOrEqual(5); // Must have 5 or less elements +s.string.array.lengthGreaterThan(5); // Must have more than 5 elements +s.string.array.lengthGreaterThanOrEqual(5); // Must have 5 or more elements +s.string.array.lengthEqual(5); // Must have exactly 5 elements +s.string.array.lengthNotEqual(5); // Must not have exactly 5 elements +s.string.array.lengthRange(0, 4); // Must have at least 0 elements and less than 4 elements (in math, that is [0, 4)) +s.string.array.lengthRangeInclusive(0, 4); // Must have at least 0 elements and at most 4 elements (in math, that is [0, 4]) +s.string.array.lengthRangeExclusive(0, 4); // Must have more than 0 element and less than 4 elements (in math, that is (0, 4)) +s.string.array.unique; // All elements must be unique. Deep equality is used to check for uniqueness. +``` + +> **Note**: All `.length` methods define tuple types with the given amount of elements. For example, +> `s.string.array.lengthGreaterThanOrEqual(2)`'s inferred type is `[string, string, ...string[]]` + +#### Tuples + +[Back to top][toc] + +Unlike arrays, tuples have a fixed number of elements and each element can have a different type: + +```typescript +const dish = s.tuple([ + s.string, // Dish's name + s.number.int, // Table's number + s.date // Date the dish was ready for delivery +]); + +dish.parse(['Iberian ham', 10, new Date()]); +``` + +#### Unions + +[Back to top][toc] + +Shapeshift includes a built-in method for composing OR types: + +```typescript +const stringOrNumber = s.union(s.string, s.number); + +stringOrNumber.parse('Sapphire'); // => 'Sapphire' +stringOrNumber.parse(42); // => 42 +stringOrNumber.parse({}); // => throws CombinedError +``` + +#### Enums + +[Back to top][toc] + +Enums are a convenience method that aliases `s.union(s.literal(a), s.literal(b), ...)`: + +```typescript +s.enum('Red', 'Green', 'Blue'); +// s.union(s.literal('Red'), s.literal('Green'), s.literal('Blue')); +``` + +#### Maps + +[Back to top][toc] + +```typescript +const map = s.map(s.string, s.number); +// Map<string, number> +``` + +#### Sets + +[Back to top][toc] + +```typescript +const set = s.set(s.number); +// Set<number> +``` + +#### Instances + +[Back to top][toc] + +You can use `s.instance(Class)` to check that the input is an instance of a class. This is useful to validate inputs +against classes: + +```typescript +class User { + public constructor(public name: string) {} +} + +const userInstanceValidation = s.instance(User); +userInstanceValidation.parse(new User('Sapphire')); // => User { name: 'Sapphire' } +userInstanceValidation.parse('oops'); // => throws ValidatorError +``` + +#### Records + +[Back to top][toc] + +Record validations are similar to objects, but validate `Record<string, T>` types. Keep in mind this does not check for +the keys, and cannot support validation for specific ones: + +```typescript +const tags = s.record(s.string); + +tags.parse({ foo: 'bar', hello: 'world' }); // => { foo: 'bar', hello: 'world' } +tags.parse({ foo: 42 }); // => throws CombinedError +tags.parse('Hello'); // => throws ValidateError +``` + +--- + +_**Function validation is not yet implemented and will be made available starting v2.1.0**_ + +#### Functions // TODO + +[Back to top][toc] + +You can define function validations. This checks for whether or not an input is a function: + +```typescript +s.function; // () => unknown +``` + +You can define arguments by passing an array as the first argument, as well as the return type as the second: + +```typescript +s.function([s.string]); // (arg0: string) => unknown +s.function([s.string, s.number], s.string); // (arg0: string, arg1: number) => string +``` + +> **Note**: Shapeshift will transform the given function into one with validation on arguments and output. You can +> access the `.raw` property of the function to get the unchecked function. + +--- + +#### TypedArray + +[Back to top][toc] + +```ts +const typedArray = s.typedArray(); +const int16Array = s.int16Array; +const uint16Array = s.uint16Array; +const uint8ClampedArray = s.uint8ClampedArray; +const int16Array = s.int16Array; +const uint16Array = s.uint16Array; +const int32Array = s.int32Array; +const uint32Array = s.uint32Array; +const float32Array = s.float32Array; +const float64Array = s.float64Array; +const bigInt64Array = s.bigInt64Array; +const bigUint64Array = s.bigUint64Array; +``` + +Shapeshift includes a handful of validations specific to typed arrays. + +```typescript +s.typedArray().lengthLessThan(5); // Length must be less than 5 +s.typedArray().lengthLessThanOrEqual(5); // Length must be 5 or less +s.typedArray().lengthGreaterThan(5); // Length must be more than 5 +s.typedArray().lengthGreaterThanOrEqual(5); // Length must be 5 or more +s.typedArray().lengthEqual(5); // Length must be exactly 5 +s.typedArray().lengthNotEqual(5); // Length must not be 5 +s.typedArray().lengthRange(0, 4); // Length L must satisfy 0 <= L < 4 +s.typedArray().lengthRangeInclusive(0, 4); // Length L must satisfy 0 <= L <= 4 +s.typedArray().lengthRangeExclusive(0, 4); // Length L must satisfy 0 < L < 4 +``` + +Note that all of these methods have analogous methods for working with the typed array's byte length, +`s.typedArray().byteLengthX()` - for instance, `s.typedArray().byteLengthLessThan(5)` is the same as +`s.typedArray().lengthLessThan(5)` but for the array's byte length. + +--- + +### Defining schemas (objects) + +[Back to top][toc] + +```typescript +// Properties are required by default: +const animal = s.object({ + name: s.string, + age: s.number +}); +``` + +#### Utility types for TypeScript + +[Back to top][toc] + +For object validation Shapeshift exports 2 utility types that can be used to extract interfaces from schemas and define +the structure of a schema as an interface beforehand respectively. + +##### Extracting an interface from a schema + +[Back to top][toc] + +You can use the `InferType` type to extract the interface from a schema, for example: + +```typescript +import { InferType, s } from '@sapphire/shapeshift'; + +const schema = s.object({ + foo: s.string, + bar: s.number, + baz: s.boolean, + qux: s.bigint, + quux: s.date +}); + +type Inferredtype = InferType<typeof schema>; + +// Expected type: +type Inferredtype = { + foo: string; + bar: number; + baz: boolean; + qux: bigint; + quux: Date; +}; +``` + +##### Defining the structure of a schema through an interface + +[Back to top][toc] + +You can use the `SchemaOf` type to define the structure of a schema before defining the actual schema, for example: + +```typescript +import { s, SchemaOf } from '@sapphire/shapeshift'; + +interface IIngredient { + ingredientId: string | undefined; + name: string | undefined; +} + +interface IInstruction { + instructionId: string | undefined; + message: string | undefined; +} + +interface IRecipe { + recipeId: string | undefined; + title: string; + description: string; + instructions: IInstruction[]; + ingredients: IIngredient[]; +} + +type InstructionSchemaType = SchemaOf<IInstruction>; +// Expected Type: ObjectValidator<IInstruction> + +type IngredientSchemaType = SchemaOf<IIngredient>; +// Expected Type: ObjectValidator<IIngredient> + +type RecipeSchemaType = SchemaOf<IRecipe>; +// Expected Type: ObjectValidator<IRecipe> + +const instructionSchema: InstructionSchemaType = s.object({ + instructionId: s.string.optional, + message: s.string +}); + +const ingredientSchema: IngredientSchemaType = s.object({ + ingredientId: s.string.optional, + name: s.string +}); + +const recipeSchema: RecipeSchemaType = s.object({ + recipeId: s.string.optional, + title: s.string, + description: s.string, + instructions: s.array(instructionSchema), + ingredients: s.array(ingredientSchema) +}); +``` + +#### `.extend`: + +[Back to top][toc] + +You can add additional fields using either an object or an ObjectValidator, in this case, you will get a new object +validator with the merged properties: + +```typescript +const animal = s.object({ + name: s.string.optional, + age: s.number +}); + +const pet = animal.extend({ + owner: s.string.nullish +}); + +const pet = animal.extend( + s.object({ + owner: s.string.nullish + }) +); +``` + +> If both schemas share keys, an error will be thrown. Please use `.omit` on the first object if you desire this +> behaviour. + +#### `.pick` / `.omit`: + +[Back to top][toc] + +Inspired by TypeScript's built-in `Pick` and `Omit` utility types, all object schemas have the aforementioned methods +that return a modifier version: + +```typescript +const pkg = s.object({ + name: s.string, + description: s.string, + dependencies: s.string.array +}); + +const justTheName = pkg.pick(['name']); +// s.object({ name: s.string }); + +const noDependencies = pkg.omit(['dependencies']); +// s.object({ name: s.string, description: s.string }); +``` + +#### `.partial` + +[Back to top][toc] + +Inspired by TypeScript's built-in `Partial` utility type, all object schemas have the aforementioned method that makes +all properties optional: + +```typescript +const user = s.object({ + username: s.string, + password: s.string +}).partial; +``` + +Which is the same as doing: + +```typescript +const user = s.object({ + username: s.string.optional, + password: s.string.optional +}); +``` + +--- + +#### `.required` + +[Back to top][toc] + +Inspired by TypeScript's built-in `Required` utility type, all object schemas have the aforementioned method that makes +all properties required: + +```typescript +const user = s.object({ + username: s.string.optional, + password: s.string.optional +}).required; +``` + +Which is the same as doing: + +```typescript +const user = s.object({ + username: s.string, + password: s.string +}); +``` + +--- + +### Handling unrecognized keys + +[Back to top][toc] + +By default, Shapeshift will not include keys that are not defined by the schema during parsing: + +```typescript +const person = s.object({ + framework: s.string +}); + +person.parse({ + framework: 'Sapphire', + awesome: true +}); +// => { name: 'Sapphire' } +``` + +#### `.strict` + +[Back to top][toc] + +You can disallow unknown keys with `.strict`. If the input includes any unknown keys, an error will be thrown. + +```typescript +const person = s.object({ + framework: s.string +}).strict; + +person.parse({ + framework: 'Sapphire', + awesome: true +}); +// => throws ValidationError +``` + +#### `.ignore` + +[Back to top][toc] + +You can use the `.ignore` getter to reset an object schema to the default behaviour (ignoring unrecognized keys). + +#### `.passthrough` + +[Back to top][toc] + +You can use the `.passthrough` getter to make the validator add the unrecognized properties the shape does not have, +from the input. + +--- + +### BaseValidator: methods and properties + +[Back to top][toc] + +All validations in Shapeshift contain certain methods. + +- #### `.run(data: unknown): Result<T, Error>`: given a validation, you can call this method to check whether or not the + + input is valid. If it is, a `Result` with `success: true` and a deep-cloned value will be returned with the given + constraints and transformations. Otherwise, a `Result` with `success: false` and an error is returned. + +- #### `.parse(data: unknown): T`: given a validations, you can call this method to check whether or not the input is valid. + + If it is, a deep-cloned value will be returned with the given constraints and transformations. Otherwise, an error is + thrown. + +- #### `.transform<R>((value: T) => R): NopValidator<R>`: adds a constraint that modifies the input: + +```typescript +import { s } from '@sapphire/shapeshift'; + +const getLength = s.string.transform((value) => value.length); +getLength.parse('Hello There'); // => 11 +``` + +> :warning: `.transform`'s functions **must not throw**. If a validation error is desired to be thrown, `.reshape` +> instead. + +- #### `.reshape<R>((value: T) => Result<R, Error> | IConstraint): NopValidator<R>`: adds a constraint able to both validate + and modify the input: + +```typescript +import { s, Result } from '@sapphire/shapeshift'; + +const getLength = s.string.reshape((value) => Result.ok(value.length)); +getLength.parse('Hello There'); // => 11 +``` + +> :warning: `.reshape`'s functions **must not throw**. If a validation error is desired to be thrown, use +> `Result.err(error)` instead. + +- #### `.default(value: T | (() => T))`: transform `undefined` into the given value or the callback's returned value: + +```typescript +const name = s.string.default('Sapphire'); +name.parse('Hello'); // => 'Hello' +name.parse(undefined); // => 'Sapphire' +``` + +```typescript +const number = s.number.default(Math.random); +number.parse(12); // => 12 +number.parse(undefined); // => 0.989911985608602 +number.parse(undefined); // => 0.3224350185068794 +``` + +> :warning: The default values are not validated. + +- #### `.optional`: a convenience method that returns a union of the type with `s.undefined`. + +```typescript +s.string.optional; // s.union(s.string, s.undefined) +``` + +- #### `.nullable`: a convenience method that returns a union of the type with `s.nullable`. + +```typescript +s.string.nullable; // s.union(s.string, s.nullable) +``` + +- #### `.nullish`: a convenience method that returns a union of the type with `s.nullish`. + +```typescript +s.string.nullish; // s.union(s.string, s.nullish) +``` + +- #### `.array`: a convenience method that returns an ArrayValidator with the type. + +```typescript +s.string.array; // s.array(s.string) +``` + +- #### `.or`: a convenience method that returns an UnionValidator with the type. This method is also overridden in + UnionValidator to just append one more entry. + +```typescript +s.string.or(s.number); +// => s.union(s.string, s.number) + +s.object({ name: s.string }).or(s.string, s.number); +// => s.union(s.object({ name: s.string }), s.string, s.number) +``` + +- #### `.when`: Adjust the schema based on a sibling or sinbling children fields. + +For using when you provide an object literal where the key `is` is undefined, a value, or a matcher function; `then` +provides the schema when `is` resolves truthy, and `otherwise` provides the schema when `is` resolves falsey. + +##### Available options for providing `is` + +When `is` is not provided (`=== undefined`) it is strictly resolved as `Boolean(value)` wherein `value` is the current +value of the referenced sibling. Note that if multiple siblings are referenced then all the values of the array need to +resolve truthy for the `is` to resolve truthy. + +When `is` is a primitive literal it is strictly compared (`===`) to the current value. + +If you want to use a different form of equality you can provide a function like: `is: (value) => value === true`. + +##### Resolving of the `key` (first) parameter + +For resolving the `key` parameter to its respective value we use [lodash/get](https://lodash.com/docs#get). This means +that every way that Lodash supports resolving a key to its respective value is also supported by Shapeshift. This +includes: + +- Simply providing a string or number like `'name'` or `1`. +- Providing a string or number with a dot notation like `'name.first'` (representative of a nested object structure of + `{ 'name': { 'first': 'Sapphire' } }` => resolves to `Sapphire`). +- Providing a string or number with a bracket notation like `'name[0]'` (representative of an array structure of + `{ 'name': ['Sapphire', 'Framework'] }` => resolves to `Sapphire`). +- Providing a string or number with a dot and bracket notation like `'name[1].first'` (representative of a nested object + structure of `{ 'name': [{ 'first': 'Sapphire' }, { 'first': 'Framework' }] }` => resolves to `Framework`). + +##### Examples + +Let's start with a basic example: + +```typescript +const whenPredicate = s.object({ + booleanLike: s.boolean, + numberLike: s.number.when('booleanLike', { + then: (schema) => schema.greaterThanOrEqual(5), + otherwise: (schema) => schema.lessThanOrEqual(5) + }) +}); + +whenPredicate.parse({ booleanLike: true, numberLike: 6 }); +// => { booleanLike: true, numberLike: 6 } + +whenPredicate.parse({ booleanLike: true, numberLike: 4 }); +// => ExpectedConstraintError('s.number.greaterThanOrEqual', 'Invalid number value', 4, 'expected >= 5') + +whenPredicate.parse({ booleanLike: false, numberLike: 4 }); +// => { booleanLike: false, numberLike: 4 } +``` + +The provided key can also be an array of sibling children: + +```typescript +const whenPredicate = s.object({ + booleanLike: s.boolean, + stringLike: s.string, + numberLike: s.number.when(['booleanLike', 'stringLike'], { + is: ([booleanLikeValue, stringLikeValue]) => booleanLikeValue === true && stringLikeValue === 'foobar', + then: (schema) => schema.greaterThanOrEqual(5), + otherwise: (schema) => schema.lessThanOrEqual(5) + }) +}); + +whenPredicate.parse({ booleanLike: true, stringLike: 'foobar', numberLike: 6 }); +// => { booleanLike: true, numberLike: 6 } + +whenPredicate.parse({ booleanLike: true, stringLike: 'barfoo', numberLike: 4 }); +// => ExpectedConstraintError('s.number.greaterThanOrEqual', 'Invalid number value', 4, 'expected >= 5') + +whenPredicate.parse({ booleanLike: false, stringLike: 'foobar' numberLike: 4 }); +// => ExpectedConstraintError('s.number.greaterThanOrEqual', 'Invalid number value', 4, 'expected >= 5') +``` + +### Enabling and disabling validation + +[Back to top][toc] + +At times, you might want to have a consistent code base with validation, but would like to keep validation to the strict +necessities instead of the in-depth constraints available in shapeshift. By calling `setGlobalValidationEnabled` you can +disable validation at a global level, and by calling `setValidationEnabled` you can disable validation on a +per-validator level. + +> When setting the validation enabled status per-validator, you can also set it to `null` to use the global setting. + +```typescript +import { setGlobalValidationEnabled } from '@sapphire/shapeshift'; + +setGlobalValidationEnabled(false); +``` + +```typescript +import { s } from '@sapphire/shapeshift'; + +const predicate = s.string.lengthGreaterThan(5).setValidationEnabled(false); +``` + +## Buy us some doughnuts + +[Back to top][toc] + +Sapphire Community is and always will be open source, even if we don't get donations. That being said, we know there are +amazing people who may still want to donate just to show their appreciation. Thank you very much in advance! + +We accept donations through Open Collective, Ko-fi, Paypal, Patreon and GitHub Sponsorships. You can use the buttons +below to donate through your method of choice. + +| Donate With | Address | +| :-------------: | :-------------------------------------------------: | +| Open Collective | [Click Here](https://sapphirejs.dev/opencollective) | +| Ko-fi | [Click Here](https://sapphirejs.dev/kofi) | +| Patreon | [Click Here](https://sapphirejs.dev/patreon) | +| PayPal | [Click Here](https://sapphirejs.dev/paypal) | + +## Contributors + +[Back to top][toc] + +Please make sure to read the [Contributing Guide][contributing] before making a pull request. + +Thank you to all the people who already contributed to Sapphire! + +<a href="https://github.com/sapphiredev/shapeshift/graphs/contributors"> + <img src="https://contrib.rocks/image?repo=sapphiredev/shapeshift" /> +</a> + +[contributing]: https://github.com/sapphiredev/.github/blob/main/.github/CONTRIBUTING.md +[`zod`]: https://github.com/colinhacks/zod +[documentation]: https://www.sapphirejs.dev/docs/Documentation/api-shapeshift/ +[toc]: #table-of-contents diff --git a/node_modules/@sapphire/shapeshift/dist/index.d.ts b/node_modules/@sapphire/shapeshift/dist/index.d.ts new file mode 100644 index 0000000..748451d --- /dev/null +++ b/node_modules/@sapphire/shapeshift/dist/index.d.ts @@ -0,0 +1,715 @@ +import { InspectOptionsStylized } from 'util'; + +declare class Result<T, E extends Error = Error> { + readonly success: boolean; + readonly value?: T; + readonly error?: E; + private constructor(); + isOk(): this is { + success: true; + value: T; + }; + isErr(): this is { + success: false; + error: E; + }; + unwrap(): T; + static ok<T, E extends Error = Error>(value: T): Result<T, E>; + static err<T, E extends Error = Error>(error: E): Result<T, E>; +} + +type ArrayConstraintName = `s.array(T).${'unique' | `length${'LessThan' | 'LessThanOrEqual' | 'GreaterThan' | 'GreaterThanOrEqual' | 'Equal' | 'NotEqual' | 'Range' | 'RangeInclusive' | 'RangeExclusive'}`}`; +declare function arrayLengthLessThan<T>(value: number): IConstraint<T[]>; +declare function arrayLengthLessThanOrEqual<T>(value: number): IConstraint<T[]>; +declare function arrayLengthGreaterThan<T>(value: number): IConstraint<T[]>; +declare function arrayLengthGreaterThanOrEqual<T>(value: number): IConstraint<T[]>; +declare function arrayLengthEqual<T>(value: number): IConstraint<T[]>; +declare function arrayLengthNotEqual<T>(value: number): IConstraint<T[]>; +declare function arrayLengthRange<T>(start: number, endBefore: number): IConstraint<T[]>; +declare function arrayLengthRangeInclusive<T>(start: number, end: number): IConstraint<T[]>; +declare function arrayLengthRangeExclusive<T>(startAfter: number, endBefore: number): IConstraint<T[]>; + +type BigIntConstraintName = `s.bigint.${'lessThan' | 'lessThanOrEqual' | 'greaterThan' | 'greaterThanOrEqual' | 'equal' | 'notEqual' | 'divisibleBy'}`; +declare function bigintLessThan(value: bigint): IConstraint<bigint>; +declare function bigintLessThanOrEqual(value: bigint): IConstraint<bigint>; +declare function bigintGreaterThan(value: bigint): IConstraint<bigint>; +declare function bigintGreaterThanOrEqual(value: bigint): IConstraint<bigint>; +declare function bigintEqual(value: bigint): IConstraint<bigint>; +declare function bigintNotEqual(value: bigint): IConstraint<bigint>; +declare function bigintDivisibleBy(divider: bigint): IConstraint<bigint>; + +type BooleanConstraintName = `s.boolean.${boolean}`; +declare const booleanTrue: IConstraint<boolean, true>; +declare const booleanFalse: IConstraint<boolean, false>; + +type DateConstraintName = `s.date.${'lessThan' | 'lessThanOrEqual' | 'greaterThan' | 'greaterThanOrEqual' | 'equal' | 'notEqual' | 'valid' | 'invalid'}`; +declare function dateLessThan(value: Date): IConstraint<Date>; +declare function dateLessThanOrEqual(value: Date): IConstraint<Date>; +declare function dateGreaterThan(value: Date): IConstraint<Date>; +declare function dateGreaterThanOrEqual(value: Date): IConstraint<Date>; +declare function dateEqual(value: Date): IConstraint<Date>; +declare function dateNotEqual(value: Date): IConstraint<Date>; +declare const dateInvalid: IConstraint<Date>; +declare const dateValid: IConstraint<Date>; + +type NumberConstraintName = `s.number.${'lessThan' | 'lessThanOrEqual' | 'greaterThan' | 'greaterThanOrEqual' | 'equal' | 'equal(NaN)' | 'notEqual' | 'notEqual(NaN)' | 'int' | 'safeInt' | 'finite' | 'divisibleBy'}`; +declare function numberLessThan(value: number): IConstraint<number>; +declare function numberLessThanOrEqual(value: number): IConstraint<number>; +declare function numberGreaterThan(value: number): IConstraint<number>; +declare function numberGreaterThanOrEqual(value: number): IConstraint<number>; +declare function numberEqual(value: number): IConstraint<number>; +declare function numberNotEqual(value: number): IConstraint<number>; +declare const numberInt: IConstraint<number>; +declare const numberSafeInt: IConstraint<number>; +declare const numberFinite: IConstraint<number>; +declare const numberNaN: IConstraint<number>; +declare const numberNotNaN: IConstraint<number>; +declare function numberDivisibleBy(divider: number): IConstraint<number>; + +declare const customInspectSymbol: unique symbol; +declare const customInspectSymbolStackLess: unique symbol; +declare abstract class BaseError extends Error { + protected [customInspectSymbol](depth: number, options: InspectOptionsStylized): string; + protected abstract [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string; +} + +declare class CombinedError extends BaseError { + readonly errors: readonly BaseError[]; + constructor(errors: readonly BaseError[]); + protected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string; +} + +declare class ValidationError extends BaseError { + readonly validator: string; + readonly given: unknown; + constructor(validator: string, message: string, given: unknown); + toJSON(): { + name: string; + validator: string; + given: unknown; + }; + protected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string; +} + +declare class ExpectedValidationError<T> extends ValidationError { + readonly expected: T; + constructor(validator: string, message: string, given: unknown, expected: T); + toJSON(): { + name: string; + validator: string; + given: unknown; + expected: T; + }; + protected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string; +} + +declare class MissingPropertyError extends BaseError { + readonly property: PropertyKey; + constructor(property: PropertyKey); + toJSON(): { + name: string; + property: PropertyKey; + }; + protected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string; +} + +declare class MultiplePossibilitiesConstraintError<T = unknown> extends BaseConstraintError<T> { + readonly expected: readonly string[]; + constructor(constraint: ConstraintErrorNames, message: string, given: T, expected: readonly string[]); + toJSON(): { + name: string; + constraint: ConstraintErrorNames; + given: T; + expected: readonly string[]; + }; + protected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string; +} + +declare class UnknownEnumValueError extends BaseError { + readonly value: string | number; + readonly enumKeys: string[]; + readonly enumMappings: Map<string | number, string | number>; + constructor(value: string | number, keys: string[], enumMappings: Map<string | number, string | number>); + toJSON(): { + name: string; + value: string | number; + enumKeys: string[]; + enumMappings: [string | number, string | number][]; + }; + protected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string; +} + +declare class UnknownPropertyError extends BaseError { + readonly property: PropertyKey; + readonly value: unknown; + constructor(property: PropertyKey, value: unknown); + toJSON(): { + name: string; + property: PropertyKey; + value: unknown; + }; + protected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string; +} + +declare class BigIntValidator<T extends bigint> extends BaseValidator<T> { + lessThan(number: bigint): this; + lessThanOrEqual(number: bigint): this; + greaterThan(number: bigint): this; + greaterThanOrEqual(number: bigint): this; + equal<N extends bigint>(number: N): BigIntValidator<N>; + notEqual(number: bigint): this; + get positive(): this; + get negative(): this; + divisibleBy(number: bigint): this; + get abs(): this; + intN(bits: number): this; + uintN(bits: number): this; + protected handle(value: unknown): Result<T, ValidationError>; +} + +declare class BooleanValidator<T extends boolean = boolean> extends BaseValidator<T> { + get true(): BooleanValidator<true>; + get false(): BooleanValidator<false>; + equal<R extends true | false>(value: R): BooleanValidator<R>; + notEqual<R extends true | false>(value: R): BooleanValidator<R>; + protected handle(value: unknown): Result<T, ValidationError>; +} + +declare class DateValidator extends BaseValidator<Date> { + lessThan(date: Date | number | string): this; + lessThanOrEqual(date: Date | number | string): this; + greaterThan(date: Date | number | string): this; + greaterThanOrEqual(date: Date | number | string): this; + equal(date: Date | number | string): this; + notEqual(date: Date | number | string): this; + get valid(): this; + get invalid(): this; + protected handle(value: unknown): Result<Date, ValidationError>; +} + +declare class DefaultValidator<T> extends BaseValidator<T> { + private readonly validator; + private defaultValue; + constructor(validator: BaseValidator<T>, value: T | (() => T), constraints?: readonly IConstraint<T>[]); + default(value: Exclude<T, undefined> | (() => Exclude<T, undefined>)): DefaultValidator<Exclude<T, undefined>>; + protected handle(value: unknown): Result<T, ValidatorError>; + protected clone(): this; +} + +declare class InstanceValidator<T> extends BaseValidator<T> { + readonly expected: Constructor<T>; + constructor(expected: Constructor<T>, constraints?: readonly IConstraint<T>[]); + protected handle(value: unknown): Result<T, ExpectedValidationError<Constructor<T>>>; + protected clone(): this; +} + +declare class LiteralValidator<T> extends BaseValidator<T> { + readonly expected: T; + constructor(literal: T, constraints?: readonly IConstraint<T>[]); + protected handle(value: unknown): Result<T, ExpectedValidationError<T>>; + protected clone(): this; +} + +declare class CombinedPropertyError extends BaseError { + readonly errors: [PropertyKey, BaseError][]; + constructor(errors: [PropertyKey, BaseError][]); + protected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string; + private static formatProperty; +} + +declare class MapValidator<K, V> extends BaseValidator<Map<K, V>> { + private readonly keyValidator; + private readonly valueValidator; + constructor(keyValidator: BaseValidator<K>, valueValidator: BaseValidator<V>, constraints?: readonly IConstraint<Map<K, V>>[]); + protected clone(): this; + protected handle(value: unknown): Result<Map<K, V>, ValidationError | CombinedPropertyError>; +} + +declare class NativeEnumValidator<T extends NativeEnumLike> extends BaseValidator<T[keyof T]> { + readonly enumShape: T; + readonly hasNumericElements: boolean; + private readonly enumKeys; + private readonly enumMapping; + constructor(enumShape: T); + protected handle(value: unknown): Result<T[keyof T], ValidationError | UnknownEnumValueError>; + protected clone(): this; +} +interface NativeEnumLike { + [key: string]: string | number; + [key: number]: string; +} + +declare class NeverValidator extends BaseValidator<never> { + protected handle(value: unknown): Result<never, ValidationError>; +} + +declare class NullishValidator extends BaseValidator<undefined | null> { + protected handle(value: unknown): Result<undefined | null, ValidationError>; +} + +declare class NumberValidator<T extends number> extends BaseValidator<T> { + lessThan(number: number): this; + lessThanOrEqual(number: number): this; + greaterThan(number: number): this; + greaterThanOrEqual(number: number): this; + equal<N extends number>(number: N): NumberValidator<N>; + notEqual(number: number): this; + get int(): this; + get safeInt(): this; + get finite(): this; + get positive(): this; + get negative(): this; + divisibleBy(divider: number): this; + get abs(): this; + get sign(): this; + get trunc(): this; + get floor(): this; + get fround(): this; + get round(): this; + get ceil(): this; + protected handle(value: unknown): Result<T, ValidationError>; +} + +declare class ObjectValidator<T extends object, I = UndefinedToOptional<T>> extends BaseValidator<I> { + readonly shape: MappedObjectValidator<T>; + readonly strategy: ObjectValidatorStrategy; + private readonly keys; + private readonly handleStrategy; + private readonly requiredKeys; + private readonly possiblyUndefinedKeys; + private readonly possiblyUndefinedKeysWithDefaults; + constructor(shape: MappedObjectValidator<T>, strategy?: ObjectValidatorStrategy, constraints?: readonly IConstraint<I>[]); + get strict(): this; + get ignore(): this; + get passthrough(): this; + get partial(): ObjectValidator<{ + [Key in keyof I]?: I[Key]; + }>; + get required(): ObjectValidator<{ + [Key in keyof I]-?: I[Key]; + }>; + extend<ET extends object>(schema: ObjectValidator<ET> | MappedObjectValidator<ET>): ObjectValidator<T & ET>; + pick<K extends keyof I>(keys: readonly K[]): ObjectValidator<{ + [Key in keyof Pick<I, K>]: I[Key]; + }>; + omit<K extends keyof I>(keys: readonly K[]): ObjectValidator<{ + [Key in keyof Omit<I, K>]: I[Key]; + }>; + protected handle(value: unknown): Result<I, ValidationError | CombinedPropertyError>; + protected clone(): this; + private handleIgnoreStrategy; + private handleStrictStrategy; + private handlePassthroughStrategy; +} +declare enum ObjectValidatorStrategy { + Ignore = 0, + Strict = 1, + Passthrough = 2 +} + +declare class PassthroughValidator<T extends any | unknown> extends BaseValidator<T> { + protected handle(value: unknown): Result<T, ValidationError>; +} + +declare class RecordValidator<T> extends BaseValidator<Record<string, T>> { + private readonly validator; + constructor(validator: BaseValidator<T>, constraints?: readonly IConstraint<Record<string, T>>[]); + protected clone(): this; + protected handle(value: unknown): Result<Record<string, T>, ValidationError | CombinedPropertyError>; +} + +declare class SetValidator<T> extends BaseValidator<Set<T>> { + private readonly validator; + constructor(validator: BaseValidator<T>, constraints?: readonly IConstraint<Set<T>>[]); + protected clone(): this; + protected handle(values: unknown): Result<Set<T>, ValidationError | CombinedError>; +} + +type StringConstraintName = `s.string.${`length${'LessThan' | 'LessThanOrEqual' | 'GreaterThan' | 'GreaterThanOrEqual' | 'Equal' | 'NotEqual'}` | 'regex' | 'url' | 'uuid' | 'email' | `ip${'v4' | 'v6' | ''}` | 'date' | 'phone'}`; +type StringProtocol = `${string}:`; +type StringDomain = `${string}.${string}`; +interface UrlOptions { + allowedProtocols?: StringProtocol[]; + allowedDomains?: StringDomain[]; +} +type UUIDVersion = 1 | 3 | 4 | 5; +interface StringUuidOptions { + version?: UUIDVersion | `${UUIDVersion}-${UUIDVersion}` | null; + nullable?: boolean; +} +declare function stringLengthLessThan(length: number): IConstraint<string>; +declare function stringLengthLessThanOrEqual(length: number): IConstraint<string>; +declare function stringLengthGreaterThan(length: number): IConstraint<string>; +declare function stringLengthGreaterThanOrEqual(length: number): IConstraint<string>; +declare function stringLengthEqual(length: number): IConstraint<string>; +declare function stringLengthNotEqual(length: number): IConstraint<string>; +declare function stringEmail(): IConstraint<string>; +declare function stringUrl(options?: UrlOptions): IConstraint<string>; +declare function stringIp(version?: 4 | 6): IConstraint<string>; +declare function stringRegex(regex: RegExp): IConstraint<string, string>; +declare function stringUuid({ version, nullable }?: StringUuidOptions): IConstraint<string, string>; + +declare class StringValidator<T extends string> extends BaseValidator<T> { + lengthLessThan(length: number): this; + lengthLessThanOrEqual(length: number): this; + lengthGreaterThan(length: number): this; + lengthGreaterThanOrEqual(length: number): this; + lengthEqual(length: number): this; + lengthNotEqual(length: number): this; + get email(): this; + url(options?: UrlOptions): this; + uuid(options?: StringUuidOptions): this; + regex(regex: RegExp): this; + get date(): this; + get ipv4(): this; + get ipv6(): this; + ip(version?: 4 | 6): this; + phone(): this; + protected handle(value: unknown): Result<T, ValidationError>; +} + +declare class TupleValidator<T extends any[]> extends BaseValidator<[...T]> { + private readonly validators; + constructor(validators: BaseValidator<[...T]>[], constraints?: readonly IConstraint<[...T]>[]); + protected clone(): this; + protected handle(values: unknown): Result<[...T], ValidationError | CombinedPropertyError>; +} + +type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array; +declare const TypedArrays: { + readonly Int8Array: (x: unknown) => x is Int8Array; + readonly Uint8Array: (x: unknown) => x is Uint8Array; + readonly Uint8ClampedArray: (x: unknown) => x is Uint8ClampedArray; + readonly Int16Array: (x: unknown) => x is Int16Array; + readonly Uint16Array: (x: unknown) => x is Uint16Array; + readonly Int32Array: (x: unknown) => x is Int32Array; + readonly Uint32Array: (x: unknown) => x is Uint32Array; + readonly Float32Array: (x: unknown) => x is Float32Array; + readonly Float64Array: (x: unknown) => x is Float64Array; + readonly BigInt64Array: (x: unknown) => x is BigInt64Array; + readonly BigUint64Array: (x: unknown) => x is BigUint64Array; + readonly TypedArray: (x: unknown) => x is TypedArray; +}; +type TypedArrayName = keyof typeof TypedArrays; + +declare class TypedArrayValidator<T extends TypedArray> extends BaseValidator<T> { + private readonly type; + constructor(type: TypedArrayName, constraints?: readonly IConstraint<T>[]); + byteLengthLessThan(length: number): this; + byteLengthLessThanOrEqual(length: number): this; + byteLengthGreaterThan(length: number): this; + byteLengthGreaterThanOrEqual(length: number): this; + byteLengthEqual(length: number): this; + byteLengthNotEqual(length: number): this; + byteLengthRange(start: number, endBefore: number): this; + byteLengthRangeInclusive(startAt: number, endAt: number): this; + byteLengthRangeExclusive(startAfter: number, endBefore: number): this; + lengthLessThan(length: number): this; + lengthLessThanOrEqual(length: number): this; + lengthGreaterThan(length: number): this; + lengthGreaterThanOrEqual(length: number): this; + lengthEqual(length: number): this; + lengthNotEqual(length: number): this; + lengthRange(start: number, endBefore: number): this; + lengthRangeInclusive(startAt: number, endAt: number): this; + lengthRangeExclusive(startAfter: number, endBefore: number): this; + protected clone(): this; + protected handle(value: unknown): Result<T, ValidationError>; +} + +declare class UnionValidator<T> extends BaseValidator<T> { + private validators; + constructor(validators: readonly BaseValidator<T>[], constraints?: readonly IConstraint<T>[]); + get optional(): UnionValidator<T | undefined>; + get required(): UnionValidator<Exclude<T, undefined>>; + get nullable(): UnionValidator<T | null>; + get nullish(): UnionValidator<T | null | undefined>; + or<O>(...predicates: readonly BaseValidator<O>[]): UnionValidator<T | O>; + protected clone(): this; + protected handle(value: unknown): Result<T, ValidationError | CombinedError>; +} + +type ObjectConstraintName = `s.object(T.when)`; +type WhenKey = PropertyKey | PropertyKey[]; +interface WhenOptions<T extends BaseValidator<any>, Key extends WhenKey> { + is?: boolean | ((value: Key extends Array<any> ? any[] : any) => boolean); + then: (predicate: T) => T; + otherwise?: (predicate: T) => T; +} + +declare class ExpectedConstraintError<T = unknown> extends BaseConstraintError<T> { + readonly expected: string; + constructor(constraint: ConstraintErrorNames, message: string, given: T, expected: string); + toJSON(): { + name: string; + constraint: ConstraintErrorNames; + given: T; + expected: string; + }; + protected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string; +} + +type TypedArrayConstraintName = `s.typedArray(T).${'byteLength' | 'length'}${'LessThan' | 'LessThanOrEqual' | 'GreaterThan' | 'GreaterThanOrEqual' | 'Equal' | 'NotEqual' | 'Range' | 'RangeInclusive' | 'RangeExclusive'}`; +declare function typedArrayByteLengthLessThan<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayByteLengthLessThanOrEqual<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayByteLengthGreaterThan<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayByteLengthGreaterThanOrEqual<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayByteLengthEqual<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayByteLengthNotEqual<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayByteLengthRange<T extends TypedArray>(start: number, endBefore: number): IConstraint<T>; +declare function typedArrayByteLengthRangeInclusive<T extends TypedArray>(start: number, end: number): { + run(input: T): Result<T, Error> | Result<unknown, ExpectedConstraintError<T>>; +}; +declare function typedArrayByteLengthRangeExclusive<T extends TypedArray>(startAfter: number, endBefore: number): IConstraint<T>; +declare function typedArrayLengthLessThan<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayLengthLessThanOrEqual<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayLengthGreaterThan<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayLengthGreaterThanOrEqual<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayLengthEqual<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayLengthNotEqual<T extends TypedArray>(value: number): IConstraint<T>; +declare function typedArrayLengthRange<T extends TypedArray>(start: number, endBefore: number): IConstraint<T>; +declare function typedArrayLengthRangeInclusive<T extends TypedArray>(start: number, end: number): IConstraint<T>; +declare function typedArrayLengthRangeExclusive<T extends TypedArray>(startAfter: number, endBefore: number): IConstraint<T>; + +type ConstraintErrorNames = TypedArrayConstraintName | ArrayConstraintName | BigIntConstraintName | BooleanConstraintName | DateConstraintName | NumberConstraintName | ObjectConstraintName | StringConstraintName; +declare abstract class BaseConstraintError<T = unknown> extends BaseError { + readonly constraint: ConstraintErrorNames; + readonly given: T; + constructor(constraint: ConstraintErrorNames, message: string, given: T); +} + +interface IConstraint<Input, Return extends Input = Input> { + run(input: Input, parent?: any): Result<Return, BaseConstraintError<Input>>; +} + +declare class ArrayValidator<T extends unknown[], I = T[number]> extends BaseValidator<T> { + private readonly validator; + constructor(validator: BaseValidator<I>, constraints?: readonly IConstraint<T>[]); + lengthLessThan<N extends number>(length: N): ArrayValidator<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, N>]>>>; + lengthLessThanOrEqual<N extends number>(length: N): ArrayValidator<ExpandSmallerTuples<[...Tuple<I, N>]>>; + lengthGreaterThan<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>, I, ...T]>; + lengthGreaterThanOrEqual<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>, ...T]>; + lengthEqual<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>]>; + lengthNotEqual(length: number): ArrayValidator<[...T]>; + lengthRange<S extends number, E extends number>(start: S, endBefore: E): ArrayValidator<Exclude<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, E>]>>, ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, S>]>>>>; + lengthRangeInclusive<S extends number, E extends number>(startAt: S, endAt: E): ArrayValidator<Exclude<ExpandSmallerTuples<[...Tuple<I, E>]>, ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, S>]>>>>; + lengthRangeExclusive<S extends number, E extends number>(startAfter: S, endBefore: E): ArrayValidator<Exclude<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, E>]>>, ExpandSmallerTuples<[...Tuple<T, S>]>>>; + get unique(): this; + protected clone(): this; + protected handle(values: unknown): Result<T, ValidationError | CombinedPropertyError>; +} + +declare abstract class BaseValidator<T> { + description?: string; + protected parent?: object; + protected constraints: readonly IConstraint<T>[]; + protected isValidationEnabled: boolean | (() => boolean) | null; + constructor(constraints?: readonly IConstraint<T>[]); + setParent(parent: object): this; + get optional(): UnionValidator<T | undefined>; + get nullable(): UnionValidator<T | null>; + get nullish(): UnionValidator<T | null | undefined>; + get array(): ArrayValidator<T[]>; + get set(): SetValidator<T>; + or<O>(...predicates: readonly BaseValidator<O>[]): UnionValidator<T | O>; + transform(cb: (value: T) => T): this; + transform<O>(cb: (value: T) => O): BaseValidator<O>; + reshape(cb: (input: T) => Result<T>): this; + reshape<R extends Result<unknown>, O = InferResultType<R>>(cb: (input: T) => R): BaseValidator<O>; + default(value: Exclude<T, undefined> | (() => Exclude<T, undefined>)): DefaultValidator<Exclude<T, undefined>>; + when<Key extends WhenKey, This extends BaseValidator<any> = this>(key: Key, options: WhenOptions<This, Key>): this; + describe(description: string): this; + run(value: unknown): Result<T, BaseError>; + parse<R extends T = T>(value: unknown): R; + is<R extends T = T>(value: unknown): value is R; + /** + * 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: boolean | (() => boolean) | null): this; + getValidationEnabled(): boolean | null; + protected get shouldRunConstraints(): boolean; + protected clone(): this; + protected abstract handle(value: unknown): Result<T, ValidatorError>; + protected addConstraint(constraint: IConstraint<T>): this; +} +type ValidatorError = ValidationError | CombinedError | CombinedPropertyError | UnknownEnumValueError; + +type Constructor<T> = (new (...args: readonly any[]) => T) | (abstract new (...args: readonly any[]) => T); +type Type<V> = V extends BaseValidator<infer T> ? T : never; +/** + * @deprecated Use `object` instead. + */ +type NonNullObject = {} & object; +/** + * @deprecated This type is no longer used and will be removed in the next major version. + */ +type PickDefined<T> = { + [K in keyof T as undefined extends T[K] ? never : K]: T[K]; +}; +/** + * @deprecated This type is no longer used and will be removed in the next major version. + */ +type PickUndefinedMakeOptional<T> = { + [K in keyof T as undefined extends T[K] ? K : never]+?: Exclude<T[K], undefined>; +}; +type FilterDefinedKeys<TObj extends object> = Exclude<{ + [TKey in keyof TObj]: undefined extends TObj[TKey] ? never : TKey; +}[keyof TObj], undefined>; +type UndefinedToOptional<T extends object> = Pick<T, FilterDefinedKeys<T>> & { + [k in keyof Omit<T, FilterDefinedKeys<T>>]?: Exclude<T[k], undefined>; +}; +type MappedObjectValidator<T> = { + [key in keyof T]: BaseValidator<T[key]>; +}; +/** + * An alias of {@link ObjectValidator} with a name more common among object validation libraries. + * This is the type of a schema after using `s.object({ ... })` + * @example + * ```typescript + * import { s, SchemaOf } from '@sapphire/shapeshift'; + * + * interface IIngredient { + * ingredientId: string | undefined; + * name: string | undefined; + * } + * + * interface IInstruction { + * instructionId: string | undefined; + * message: string | undefined; + * } + * + * interface IRecipe { + * recipeId: string | undefined; + * title: string; + * description: string; + * instructions: IInstruction[]; + * ingredients: IIngredient[]; + * } + * + * type InstructionSchemaType = SchemaOf<IInstruction>; + * // Expected Type: ObjectValidator<IInstruction> + * + * type IngredientSchemaType = SchemaOf<IIngredient>; + * // Expected Type: ObjectValidator<IIngredient> + * + * type RecipeSchemaType = SchemaOf<IRecipe>; + * // Expected Type: ObjectValidator<IRecipe> + * + * const instructionSchema: InstructionSchemaType = s.object({ + * instructionId: s.string.optional, + * message: s.string + * }); + * + * const ingredientSchema: IngredientSchemaType = s.object({ + * ingredientId: s.string.optional, + * name: s.string + * }); + * + * const recipeSchema: RecipeSchemaType = s.object({ + * recipeId: s.string.optional, + * title: s.string, + * description: s.string, + * instructions: s.array(instructionSchema), + * ingredients: s.array(ingredientSchema) + * }); + * ``` + */ +type SchemaOf<T extends object> = ObjectValidator<T>; +/** + * Infers the type of a schema object given `typeof schema`. + * The schema has to extend {@link ObjectValidator}. + * @example + * ```typescript + * import { InferType, s } from '@sapphire/shapeshift'; + * + * const schema = s.object({ + * foo: s.string, + * bar: s.number, + * baz: s.boolean, + * qux: s.bigint, + * quux: s.date + * }); + * + * type Inferredtype = InferType<typeof schema>; + * // Expected type: + * // type Inferredtype = { + * // foo: string; + * // bar: number; + * // baz: boolean; + * // qux: bigint; + * // quux: Date; + * // }; + * ``` + */ +type InferType<T extends ObjectValidator<any>> = T extends ObjectValidator<any, infer U> ? U : never; +type InferResultType<T extends Result<any>> = T extends Result<infer U> ? U : never; +type UnwrapTuple<T extends [...any[]]> = T extends [infer Head, ...infer Tail] ? [Unwrap<Head>, ...UnwrapTuple<Tail>] : []; +type Unwrap<T> = T extends BaseValidator<infer V> ? V : never; +type UnshiftTuple<T extends [...any[]]> = T extends [T[0], ...infer Tail] ? Tail : never; +type ExpandSmallerTuples<T extends [...any[]]> = T extends [T[0], ...infer Tail] ? T | ExpandSmallerTuples<Tail> : []; +type Shift<A extends Array<any>> = ((...args: A) => void) extends (...args: [A[0], ...infer R]) => void ? R : never; +type GrowExpRev<A extends Array<any>, N extends number, P extends Array<Array<any>>> = A['length'] extends N ? A : GrowExpRev<[...A, ...P[0]][N] extends undefined ? [...A, ...P[0]] : A, N, Shift<P>>; +type GrowExp<A extends Array<any>, N extends number, P extends Array<Array<any>>> = [...A, ...A][N] extends undefined ? GrowExp<[...A, ...A], N, [A, ...P]> : GrowExpRev<A, N, P>; +type Tuple<T, N extends number> = N extends number ? number extends N ? Array<T> : N extends 0 ? [] : N extends 1 ? [T] : GrowExp<[T], N, [[]]> : never; + +declare class LazyValidator<T extends BaseValidator<unknown>, R = Unwrap<T>> extends BaseValidator<R> { + private readonly validator; + constructor(validator: (value: unknown) => T, constraints?: readonly IConstraint<R>[]); + protected clone(): this; + protected handle(values: unknown): Result<R, ValidatorError>; +} + +declare class Shapes { + get string(): StringValidator<string>; + get number(): NumberValidator<number>; + get bigint(): BigIntValidator<bigint>; + get boolean(): BooleanValidator<boolean>; + get date(): DateValidator; + object<T extends object>(shape: MappedObjectValidator<T>): ObjectValidator<T, UndefinedToOptional<T>>; + get undefined(): BaseValidator<undefined>; + get null(): BaseValidator<null>; + get nullish(): NullishValidator; + get any(): PassthroughValidator<any>; + get unknown(): PassthroughValidator<unknown>; + get never(): NeverValidator; + enum<T>(...values: readonly T[]): UnionValidator<T>; + nativeEnum<T extends NativeEnumLike>(enumShape: T): NativeEnumValidator<T>; + literal<T>(value: T): BaseValidator<T>; + instance<T>(expected: Constructor<T>): InstanceValidator<T>; + union<T extends [...BaseValidator<any>[]]>(...validators: [...T]): UnionValidator<Unwrap<T[number]>>; + array<T>(validator: BaseValidator<T[][number]>): ArrayValidator<T[], T[][number]>; + array<T extends unknown[]>(validator: BaseValidator<T[number]>): ArrayValidator<T, T[number]>; + typedArray<T extends TypedArray>(type?: TypedArrayName): TypedArrayValidator<T>; + get int8Array(): TypedArrayValidator<Int8Array>; + get uint8Array(): TypedArrayValidator<Uint8Array>; + get uint8ClampedArray(): TypedArrayValidator<Uint8ClampedArray>; + get int16Array(): TypedArrayValidator<Int16Array>; + get uint16Array(): TypedArrayValidator<Uint16Array>; + get int32Array(): TypedArrayValidator<Int32Array>; + get uint32Array(): TypedArrayValidator<Uint32Array>; + get float32Array(): TypedArrayValidator<Float32Array>; + get float64Array(): TypedArrayValidator<Float64Array>; + get bigInt64Array(): TypedArrayValidator<BigInt64Array>; + get bigUint64Array(): TypedArrayValidator<BigUint64Array>; + tuple<T extends [...BaseValidator<any>[]]>(validators: [...T]): TupleValidator<UnwrapTuple<T>>; + set<T>(validator: BaseValidator<T>): SetValidator<T>; + record<T>(validator: BaseValidator<T>): RecordValidator<T>; + map<T, U>(keyValidator: BaseValidator<T>, valueValidator: BaseValidator<U>): MapValidator<T, U>; + lazy<T extends BaseValidator<unknown>>(validator: (value: unknown) => T): LazyValidator<T, Unwrap<T>>; +} + +/** + * Sets whether validators should run on the input, or if the input should be passed through. + * @param enabled Whether validation should be done on inputs + */ +declare function setGlobalValidationEnabled(enabled: boolean): void; +/** + * @returns Whether validation is enabled + */ +declare function getGlobalValidationEnabled(): boolean; + +declare const s: Shapes; + +export { ArrayConstraintName, ArrayValidator, BaseConstraintError, BaseError, BaseValidator, BigIntConstraintName, BigIntValidator, BooleanConstraintName, BooleanValidator, CombinedError, CombinedPropertyError, ConstraintErrorNames, Constructor, DateConstraintName, DateValidator, DefaultValidator, ExpandSmallerTuples, ExpectedConstraintError, ExpectedValidationError, GrowExp, GrowExpRev, IConstraint, InferResultType, InferType, InstanceValidator, LiteralValidator, MapValidator, MappedObjectValidator, MissingPropertyError, MultiplePossibilitiesConstraintError, NativeEnumLike, NativeEnumValidator, NeverValidator, NonNullObject, NullishValidator, NumberConstraintName, NumberValidator, ObjectValidator, ObjectValidatorStrategy, PassthroughValidator, PickDefined, PickUndefinedMakeOptional, RecordValidator, Result, SchemaOf, SetValidator, Shapes, Shift, StringConstraintName, StringDomain, StringProtocol, StringUuidOptions, StringValidator, Tuple, TupleValidator, Type, TypedArrayConstraintName, TypedArrayValidator, UUIDVersion, UndefinedToOptional, UnionValidator, UnknownEnumValueError, UnknownPropertyError, UnshiftTuple, Unwrap, UnwrapTuple, UrlOptions, ValidationError, ValidatorError, arrayLengthEqual, arrayLengthGreaterThan, arrayLengthGreaterThanOrEqual, arrayLengthLessThan, arrayLengthLessThanOrEqual, arrayLengthNotEqual, arrayLengthRange, arrayLengthRangeExclusive, arrayLengthRangeInclusive, bigintDivisibleBy, bigintEqual, bigintGreaterThan, bigintGreaterThanOrEqual, bigintLessThan, bigintLessThanOrEqual, bigintNotEqual, booleanFalse, booleanTrue, customInspectSymbol, customInspectSymbolStackLess, dateEqual, dateGreaterThan, dateGreaterThanOrEqual, dateInvalid, dateLessThan, dateLessThanOrEqual, dateNotEqual, dateValid, getGlobalValidationEnabled, numberDivisibleBy, numberEqual, numberFinite, numberGreaterThan, numberGreaterThanOrEqual, numberInt, numberLessThan, numberLessThanOrEqual, numberNaN, numberNotEqual, numberNotNaN, numberSafeInt, s, setGlobalValidationEnabled, stringEmail, stringIp, stringLengthEqual, stringLengthGreaterThan, stringLengthGreaterThanOrEqual, stringLengthLessThan, stringLengthLessThanOrEqual, stringLengthNotEqual, stringRegex, stringUrl, stringUuid, typedArrayByteLengthEqual, typedArrayByteLengthGreaterThan, typedArrayByteLengthGreaterThanOrEqual, typedArrayByteLengthLessThan, typedArrayByteLengthLessThanOrEqual, typedArrayByteLengthNotEqual, typedArrayByteLengthRange, typedArrayByteLengthRangeExclusive, typedArrayByteLengthRangeInclusive, typedArrayLengthEqual, typedArrayLengthGreaterThan, typedArrayLengthGreaterThanOrEqual, typedArrayLengthLessThan, typedArrayLengthLessThanOrEqual, typedArrayLengthNotEqual, typedArrayLengthRange, typedArrayLengthRangeExclusive, typedArrayLengthRangeInclusive }; 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 diff --git a/node_modules/@sapphire/shapeshift/dist/index.global.js.map b/node_modules/@sapphire/shapeshift/dist/index.global.js.map new file mode 100644 index 0000000..566f0c9 --- /dev/null +++ b/node_modules/@sapphire/shapeshift/dist/index.global.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../node_modules/lodash/isArray.js","../node_modules/lodash/_freeGlobal.js","../node_modules/lodash/_root.js","../node_modules/lodash/_Symbol.js","../node_modules/lodash/_getRawTag.js","../node_modules/lodash/_objectToString.js","../node_modules/lodash/_baseGetTag.js","../node_modules/lodash/isObjectLike.js","../node_modules/lodash/isSymbol.js","../node_modules/lodash/_isKey.js","../node_modules/lodash/isObject.js","../node_modules/lodash/isFunction.js","../node_modules/lodash/_coreJsData.js","../node_modules/lodash/_isMasked.js","../node_modules/lodash/_toSource.js","../node_modules/lodash/_baseIsNative.js","../node_modules/lodash/_getValue.js","../node_modules/lodash/_getNative.js","../node_modules/lodash/_nativeCreate.js","../node_modules/lodash/_hashClear.js","../node_modules/lodash/_hashDelete.js","../node_modules/lodash/_hashGet.js","../node_modules/lodash/_hashHas.js","../node_modules/lodash/_hashSet.js","../node_modules/lodash/_Hash.js","../node_modules/lodash/_listCacheClear.js","../node_modules/lodash/eq.js","../node_modules/lodash/_assocIndexOf.js","../node_modules/lodash/_listCacheDelete.js","../node_modules/lodash/_listCacheGet.js","../node_modules/lodash/_listCacheHas.js","../node_modules/lodash/_listCacheSet.js","../node_modules/lodash/_ListCache.js","../node_modules/lodash/_Map.js","../node_modules/lodash/_mapCacheClear.js","../node_modules/lodash/_isKeyable.js","../node_modules/lodash/_getMapData.js","../node_modules/lodash/_mapCacheDelete.js","../node_modules/lodash/_mapCacheGet.js","../node_modules/lodash/_mapCacheHas.js","../node_modules/lodash/_mapCacheSet.js","../node_modules/lodash/_MapCache.js","../node_modules/lodash/memoize.js","../node_modules/lodash/_memoizeCapped.js","../node_modules/lodash/_stringToPath.js","../node_modules/lodash/_arrayMap.js","../node_modules/lodash/_baseToString.js","../node_modules/lodash/toString.js","../node_modules/lodash/_castPath.js","../node_modules/lodash/_toKey.js","../node_modules/lodash/_baseGet.js","../node_modules/lodash/get.js","../node_modules/fast-deep-equal/es6/index.js","../node_modules/lodash/_setCacheAdd.js","../node_modules/lodash/_setCacheHas.js","../node_modules/lodash/_SetCache.js","../node_modules/lodash/_baseFindIndex.js","../node_modules/lodash/_baseIsNaN.js","../node_modules/lodash/_strictIndexOf.js","../node_modules/lodash/_baseIndexOf.js","../node_modules/lodash/_arrayIncludes.js","../node_modules/lodash/_arrayIncludesWith.js","../node_modules/lodash/_cacheHas.js","../node_modules/lodash/_Set.js","../node_modules/lodash/noop.js","../node_modules/lodash/_setToArray.js","../node_modules/lodash/_createSet.js","../node_modules/lodash/_baseUniq.js","../node_modules/lodash/uniqWith.js","../src/lib/configs.ts","../src/lib/Result.ts","../src/validators/util/getValue.ts","../src/constraints/ObjectConstrains.ts","node-modules-polyfills:util","../src/lib/errors/BaseError.ts","../src/lib/errors/BaseConstraintError.ts","../src/lib/errors/ExpectedConstraintError.ts","../src/validators/BaseValidator.ts","../src/constraints/util/isUnique.ts","../src/constraints/util/operators.ts","../src/constraints/ArrayConstraints.ts","../src/lib/errors/CombinedPropertyError.ts","../src/lib/errors/ValidationError.ts","../src/validators/ArrayValidator.ts","../src/constraints/BigIntConstraints.ts","../src/validators/BigIntValidator.ts","../src/constraints/BooleanConstraints.ts","../src/validators/BooleanValidator.ts","../src/constraints/DateConstraints.ts","../src/validators/DateValidator.ts","../src/lib/errors/ExpectedValidationError.ts","../src/validators/InstanceValidator.ts","../src/validators/LiteralValidator.ts","../src/validators/NeverValidator.ts","../src/validators/NullishValidator.ts","../src/constraints/NumberConstraints.ts","../src/validators/NumberValidator.ts","../src/lib/errors/MissingPropertyError.ts","../src/lib/errors/UnknownPropertyError.ts","../src/validators/DefaultValidator.ts","../src/lib/errors/CombinedError.ts","../src/validators/UnionValidator.ts","../src/validators/ObjectValidator.ts","../src/validators/PassthroughValidator.ts","../src/validators/RecordValidator.ts","../src/validators/SetValidator.ts","../src/constraints/util/emailValidator.ts","../src/constraints/util/net.ts","../src/constraints/util/phoneValidator.ts","../src/lib/errors/MultiplePossibilitiesConstraintError.ts","../src/constraints/util/common/combinedResultFn.ts","../src/constraints/util/urlValidators.ts","../src/constraints/StringConstraints.ts","../src/validators/StringValidator.ts","../src/validators/TupleValidator.ts","../src/validators/MapValidator.ts","../src/validators/LazyValidator.ts","../src/lib/errors/UnknownEnumValueError.ts","../src/validators/NativeEnumValidator.ts","../src/constraints/TypedArrayLengthConstraints.ts","../src/constraints/util/common/vowels.ts","../src/constraints/util/typedArray.ts","../src/validators/TypedArrayValidator.ts","../src/lib/Shapes.ts","../src/index.ts"],"names":["isArray","Symbol","e","isSymbol","isObject","isFunction","getValue","Map","get","equal","a","b","i","Set","uniqWith","s3","k","v","uniqueArray","fastDeepEqual","value","s","x"],"mappings":"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","sourcesContent":["/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var Symbol = require('./_Symbol'),\n getRawTag = require('./_getRawTag'),\n objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseGetTag = require('./_baseGetTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","var isArray = require('./isArray'),\n isSymbol = require('./isSymbol');\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n if (isArray(value)) {\n return false;\n }\n var type = typeof value;\n if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n value == null || isSymbol(value)) {\n return true;\n }\n return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n (object != null && value in Object(object));\n}\n\nmodule.exports = isKey;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var baseGetTag = require('./_baseGetTag'),\n isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\nmodule.exports = toSource;\n","var isFunction = require('./isFunction'),\n isMasked = require('./_isMasked'),\n isObject = require('./isObject'),\n toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\nfunction baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n","var baseIsNative = require('./_baseIsNative'),\n getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n this.size = 0;\n}\n\nmodule.exports = hashClear;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n var result = this.has(key) && delete this.__data__[key];\n this.size -= result ? 1 : 0;\n return result;\n}\n\nmodule.exports = hashDelete;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n var data = this.__data__;\n this.size += this.has(key) ? 0 : 1;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\nmodule.exports = hashSet;\n","var hashClear = require('./_hashClear'),\n hashDelete = require('./_hashDelete'),\n hashGet = require('./_hashGet'),\n hashHas = require('./_hashHas'),\n hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n this.__data__ = [];\n this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\nmodule.exports = assocIndexOf;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n --this.size;\n return true;\n}\n\nmodule.exports = listCacheDelete;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n ++this.size;\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\nmodule.exports = listCacheSet;\n","var listCacheClear = require('./_listCacheClear'),\n listCacheDelete = require('./_listCacheDelete'),\n listCacheGet = require('./_listCacheGet'),\n listCacheHas = require('./_listCacheHas'),\n listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n","var Hash = require('./_Hash'),\n ListCache = require('./_ListCache'),\n Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n this.size = 0;\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n}\n\nmodule.exports = mapCacheClear;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\nmodule.exports = isKeyable;\n","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\nmodule.exports = getMapData;\n","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n var result = getMapData(this, key)['delete'](key);\n this.size -= result ? 1 : 0;\n return result;\n}\n\nmodule.exports = mapCacheDelete;\n","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n var data = getMapData(this, key),\n size = data.size;\n\n data.set(key, value);\n this.size += data.size == size ? 0 : 1;\n return this;\n}\n\nmodule.exports = mapCacheSet;\n","var mapCacheClear = require('./_mapCacheClear'),\n mapCacheDelete = require('./_mapCacheDelete'),\n mapCacheGet = require('./_mapCacheGet'),\n mapCacheHas = require('./_mapCacheHas'),\n mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n","var MapCache = require('./_MapCache');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n var memoized = function() {\n var args = arguments,\n key = resolver ? resolver.apply(this, args) : args[0],\n cache = memoized.cache;\n\n if (cache.has(key)) {\n return cache.get(key);\n }\n var result = func.apply(this, args);\n memoized.cache = cache.set(key, result) || cache;\n return result;\n };\n memoized.cache = new (memoize.Cache || MapCache);\n return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nmodule.exports = memoize;\n","var memoize = require('./memoize');\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n var result = memoize(func, function(key) {\n if (cache.size === MAX_MEMOIZE_SIZE) {\n cache.clear();\n }\n return key;\n });\n\n var cache = result.cache;\n return result;\n}\n\nmodule.exports = memoizeCapped;\n","var memoizeCapped = require('./_memoizeCapped');\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n var result = [];\n if (string.charCodeAt(0) === 46 /* . */) {\n result.push('');\n }\n string.replace(rePropName, function(match, number, quote, subString) {\n result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n });\n return result;\n});\n\nmodule.exports = stringToPath;\n","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length,\n result = Array(length);\n\n while (++index < length) {\n result[index] = iteratee(array[index], index, array);\n }\n return result;\n}\n\nmodule.exports = arrayMap;\n","var Symbol = require('./_Symbol'),\n arrayMap = require('./_arrayMap'),\n isArray = require('./isArray'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n // Exit early for strings to avoid a performance hit in some environments.\n if (typeof value == 'string') {\n return value;\n }\n if (isArray(value)) {\n // Recursively convert values (susceptible to call stack limits).\n return arrayMap(value, baseToString) + '';\n }\n if (isSymbol(value)) {\n return symbolToString ? symbolToString.call(value) : '';\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = baseToString;\n","var baseToString = require('./_baseToString');\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n return value == null ? '' : baseToString(value);\n}\n\nmodule.exports = toString;\n","var isArray = require('./isArray'),\n isKey = require('./_isKey'),\n stringToPath = require('./_stringToPath'),\n toString = require('./toString');\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n if (isArray(value)) {\n return value;\n }\n return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nmodule.exports = castPath;\n","var isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n if (typeof value == 'string' || isSymbol(value)) {\n return value;\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = toKey;\n","var castPath = require('./_castPath'),\n toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n path = castPath(path, object);\n\n var index = 0,\n length = path.length;\n\n while (object != null && index < length) {\n object = object[toKey(path[index++])];\n }\n return (index && index == length) ? object : undefined;\n}\n\nmodule.exports = baseGet;\n","var baseGet = require('./_baseGet');\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\nfunction get(object, path, defaultValue) {\n var result = object == null ? undefined : baseGet(object, path);\n return result === undefined ? defaultValue : result;\n}\n\nmodule.exports = get;\n","'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';\n\n\nmodule.exports = function equal(a, b) {\n if (a === b) return true;\n\n if (a && b && typeof a == 'object' && typeof b == 'object') {\n if (a.constructor !== b.constructor) return false;\n\n var length, i, keys;\n if (Array.isArray(a)) {\n length = a.length;\n if (length != b.length) return false;\n for (i = length; i-- !== 0;)\n if (!equal(a[i], b[i])) return false;\n return true;\n }\n\n\n if ((a instanceof Map) && (b instanceof Map)) {\n if (a.size !== b.size) return false;\n for (i of a.entries())\n if (!b.has(i[0])) return false;\n for (i of a.entries())\n if (!equal(i[1], b.get(i[0]))) return false;\n return true;\n }\n\n if ((a instanceof Set) && (b instanceof Set)) {\n if (a.size !== b.size) return false;\n for (i of a.entries())\n if (!b.has(i[0])) return false;\n return true;\n }\n\n if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n length = a.length;\n if (length != b.length) return false;\n for (i = length; i-- !== 0;)\n if (a[i] !== b[i]) return false;\n return true;\n }\n\n\n if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n keys = Object.keys(a);\n length = keys.length;\n if (length !== Object.keys(b).length) return false;\n\n for (i = length; i-- !== 0;)\n if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n for (i = length; i-- !== 0;) {\n var key = keys[i];\n\n if (!equal(a[key], b[key])) return false;\n }\n\n return true;\n }\n\n // true if both NaN, false otherwise\n return a!==a && b!==b;\n};\n","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n this.__data__.set(value, HASH_UNDEFINED);\n return this;\n}\n\nmodule.exports = setCacheAdd;\n","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n return this.__data__.has(value);\n}\n\nmodule.exports = setCacheHas;\n","var MapCache = require('./_MapCache'),\n setCacheAdd = require('./_setCacheAdd'),\n setCacheHas = require('./_setCacheHas');\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n var index = -1,\n length = values == null ? 0 : values.length;\n\n this.__data__ = new MapCache;\n while (++index < length) {\n this.add(values[index]);\n }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nmodule.exports = SetCache;\n","/**\n * The base implementation of `_.findIndex` and `_.findLastIndex` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {number} fromIndex The index to search from.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseFindIndex(array, predicate, fromIndex, fromRight) {\n var length = array.length,\n index = fromIndex + (fromRight ? 1 : -1);\n\n while ((fromRight ? index-- : ++index < length)) {\n if (predicate(array[index], index, array)) {\n return index;\n }\n }\n return -1;\n}\n\nmodule.exports = baseFindIndex;\n","/**\n * The base implementation of `_.isNaN` without support for number objects.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n */\nfunction baseIsNaN(value) {\n return value !== value;\n}\n\nmodule.exports = baseIsNaN;\n","/**\n * A specialized version of `_.indexOf` which performs strict equality\n * comparisons of values, i.e. `===`.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction strictIndexOf(array, value, fromIndex) {\n var index = fromIndex - 1,\n length = array.length;\n\n while (++index < length) {\n if (array[index] === value) {\n return index;\n }\n }\n return -1;\n}\n\nmodule.exports = strictIndexOf;\n","var baseFindIndex = require('./_baseFindIndex'),\n baseIsNaN = require('./_baseIsNaN'),\n strictIndexOf = require('./_strictIndexOf');\n\n/**\n * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseIndexOf(array, value, fromIndex) {\n return value === value\n ? strictIndexOf(array, value, fromIndex)\n : baseFindIndex(array, baseIsNaN, fromIndex);\n}\n\nmodule.exports = baseIndexOf;\n","var baseIndexOf = require('./_baseIndexOf');\n\n/**\n * A specialized version of `_.includes` for arrays without support for\n * specifying an index to search from.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\nfunction arrayIncludes(array, value) {\n var length = array == null ? 0 : array.length;\n return !!length && baseIndexOf(array, value, 0) > -1;\n}\n\nmodule.exports = arrayIncludes;\n","/**\n * This function is like `arrayIncludes` except that it accepts a comparator.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @param {Function} comparator The comparator invoked per element.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\nfunction arrayIncludesWith(array, value, comparator) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (comparator(value, array[index])) {\n return true;\n }\n }\n return false;\n}\n\nmodule.exports = arrayIncludesWith;\n","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n return cache.has(key);\n}\n\nmodule.exports = cacheHas;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nmodule.exports = Set;\n","/**\n * This method returns `undefined`.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Util\n * @example\n *\n * _.times(2, _.noop);\n * // => [undefined, undefined]\n */\nfunction noop() {\n // No operation performed.\n}\n\nmodule.exports = noop;\n","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\nmodule.exports = setToArray;\n","var Set = require('./_Set'),\n noop = require('./noop'),\n setToArray = require('./_setToArray');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Creates a set object of `values`.\n *\n * @private\n * @param {Array} values The values to add to the set.\n * @returns {Object} Returns the new set.\n */\nvar createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n return new Set(values);\n};\n\nmodule.exports = createSet;\n","var SetCache = require('./_SetCache'),\n arrayIncludes = require('./_arrayIncludes'),\n arrayIncludesWith = require('./_arrayIncludesWith'),\n cacheHas = require('./_cacheHas'),\n createSet = require('./_createSet'),\n setToArray = require('./_setToArray');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n */\nfunction baseUniq(array, iteratee, comparator) {\n var index = -1,\n includes = arrayIncludes,\n length = array.length,\n isCommon = true,\n result = [],\n seen = result;\n\n if (comparator) {\n isCommon = false;\n includes = arrayIncludesWith;\n }\n else if (length >= LARGE_ARRAY_SIZE) {\n var set = iteratee ? null : createSet(array);\n if (set) {\n return setToArray(set);\n }\n isCommon = false;\n includes = cacheHas;\n seen = new SetCache;\n }\n else {\n seen = iteratee ? [] : result;\n }\n outer:\n while (++index < length) {\n var value = array[index],\n computed = iteratee ? iteratee(value) : value;\n\n value = (comparator || value !== 0) ? value : 0;\n if (isCommon && computed === computed) {\n var seenIndex = seen.length;\n while (seenIndex--) {\n if (seen[seenIndex] === computed) {\n continue outer;\n }\n }\n if (iteratee) {\n seen.push(computed);\n }\n result.push(value);\n }\n else if (!includes(seen, computed, comparator)) {\n if (seen !== result) {\n seen.push(computed);\n }\n result.push(value);\n }\n }\n return result;\n}\n\nmodule.exports = baseUniq;\n","var baseUniq = require('./_baseUniq');\n\n/**\n * This method is like `_.uniq` except that it accepts `comparator` which\n * is invoked to compare elements of `array`. The order of result values is\n * determined by the order they occur in the array.The comparator is invoked\n * with two arguments: (arrVal, othVal).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];\n *\n * _.uniqWith(objects, _.isEqual);\n * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n */\nfunction uniqWith(array, comparator) {\n comparator = typeof comparator == 'function' ? comparator : undefined;\n return (array && array.length) ? baseUniq(array, undefined, comparator) : [];\n}\n\nmodule.exports = uniqWith;\n","let validationEnabled = true;\n\n/**\n * Sets whether validators should run on the input, or if the input should be passed through.\n * @param enabled Whether validation should be done on inputs\n */\nexport function setGlobalValidationEnabled(enabled: boolean) {\n\tvalidationEnabled = enabled;\n}\n\n/**\n * @returns Whether validation is enabled\n */\nexport function getGlobalValidationEnabled() {\n\treturn validationEnabled;\n}\n","export class Result<T, E extends Error = Error> {\n\tpublic readonly success: boolean;\n\tpublic readonly value?: T;\n\tpublic readonly error?: E;\n\n\tprivate constructor(success: boolean, value?: T, error?: E) {\n\t\tthis.success = success;\n\t\tif (success) {\n\t\t\tthis.value = value;\n\t\t} else {\n\t\t\tthis.error = error;\n\t\t}\n\t}\n\n\tpublic isOk(): this is { success: true; value: T } {\n\t\treturn this.success;\n\t}\n\n\tpublic isErr(): this is { success: false; error: E } {\n\t\treturn !this.success;\n\t}\n\n\tpublic unwrap(): T {\n\t\tif (this.isOk()) return this.value;\n\t\tthrow this.error as Error;\n\t}\n\n\tpublic static ok<T, E extends Error = Error>(value: T): Result<T, E> {\n\t\treturn new Result<T, E>(true, value);\n\t}\n\n\tpublic static err<T, E extends Error = Error>(error: E): Result<T, E> {\n\t\treturn new Result<T, E>(false, undefined, error);\n\t}\n}\n","// https://github.com/microsoft/TypeScript/issues/37663\ntype Fn = (...args: unknown[]) => unknown;\n\nexport function getValue<T, U = T extends Fn ? ReturnType<T> : T>(valueOrFn: T): U {\n\treturn typeof valueOrFn === 'function' ? valueOrFn() : valueOrFn;\n}\n","import get from 'lodash/get.js';\nimport { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { BaseValidator } from '../type-exports';\nimport type { IConstraint } from './type-exports';\n\nexport type ObjectConstraintName = `s.object(T.when)`;\n\nexport type WhenKey = PropertyKey | PropertyKey[];\n\nexport interface WhenOptions<T extends BaseValidator<any>, Key extends WhenKey> {\n\tis?: boolean | ((value: Key extends Array<any> ? any[] : any) => boolean);\n\tthen: (predicate: T) => T;\n\totherwise?: (predicate: T) => T;\n}\n\nexport function whenConstraint<T extends BaseValidator<any>, I, Key extends WhenKey>(\n\tkey: Key,\n\toptions: WhenOptions<T, Key>,\n\tvalidator: T\n): IConstraint<I> {\n\treturn {\n\t\trun(input: I, parent?: any) {\n\t\t\tif (!parent) {\n\t\t\t\treturn Result.err(new ExpectedConstraintError('s.object(T.when)', 'Validator has no parent', parent, 'Validator to have a parent'));\n\t\t\t}\n\n\t\t\tconst isKeyArray = Array.isArray(key);\n\n\t\t\tconst value = isKeyArray ? key.map((k) => get(parent, k)) : get(parent, key);\n\n\t\t\tconst predicate = resolveBooleanIs<T, Key>(options, value, isKeyArray) ? options.then : options.otherwise;\n\n\t\t\tif (predicate) {\n\t\t\t\treturn predicate(validator).run(input) as Result<I, ExpectedConstraintError<I>>;\n\t\t\t}\n\n\t\t\treturn Result.ok(input);\n\t\t}\n\t};\n}\n\nfunction resolveBooleanIs<T extends BaseValidator<any>, Key extends WhenKey>(options: WhenOptions<T, Key>, value: any, isKeyArray: boolean) {\n\tif (options.is === undefined) {\n\t\treturn isKeyArray ? !value.some((val: any) => !val) : Boolean(value);\n\t}\n\n\tif (typeof options.is === 'function') {\n\t\treturn options.is(value);\n\t}\n\n\treturn value === options.is;\n}\n","// node_modules/@jspm/core/nodelibs/browser/chunk-5decc758.js\nvar e;\nvar t;\nvar n;\nvar r = \"undefined\" != typeof globalThis ? globalThis : \"undefined\" != typeof self ? self : global;\nvar o = e = {};\nfunction i() {\n throw new Error(\"setTimeout has not been defined\");\n}\nfunction u() {\n throw new Error(\"clearTimeout has not been defined\");\n}\nfunction c(e3) {\n if (t === setTimeout)\n return setTimeout(e3, 0);\n if ((t === i || !t) && setTimeout)\n return t = setTimeout, setTimeout(e3, 0);\n try {\n return t(e3, 0);\n } catch (n3) {\n try {\n return t.call(null, e3, 0);\n } catch (n4) {\n return t.call(this || r, e3, 0);\n }\n }\n}\n!function() {\n try {\n t = \"function\" == typeof setTimeout ? setTimeout : i;\n } catch (e3) {\n t = i;\n }\n try {\n n = \"function\" == typeof clearTimeout ? clearTimeout : u;\n } catch (e3) {\n n = u;\n }\n}();\nvar l;\nvar s = [];\nvar f = false;\nvar a = -1;\nfunction h() {\n f && l && (f = false, l.length ? s = l.concat(s) : a = -1, s.length && d());\n}\nfunction d() {\n if (!f) {\n var e3 = c(h);\n f = true;\n for (var t3 = s.length; t3; ) {\n for (l = s, s = []; ++a < t3; )\n l && l[a].run();\n a = -1, t3 = s.length;\n }\n l = null, f = false, function(e4) {\n if (n === clearTimeout)\n return clearTimeout(e4);\n if ((n === u || !n) && clearTimeout)\n return n = clearTimeout, clearTimeout(e4);\n try {\n n(e4);\n } catch (t4) {\n try {\n return n.call(null, e4);\n } catch (t5) {\n return n.call(this || r, e4);\n }\n }\n }(e3);\n }\n}\nfunction m(e3, t3) {\n (this || r).fun = e3, (this || r).array = t3;\n}\nfunction p() {\n}\no.nextTick = function(e3) {\n var t3 = new Array(arguments.length - 1);\n if (arguments.length > 1)\n for (var n3 = 1; n3 < arguments.length; n3++)\n t3[n3 - 1] = arguments[n3];\n s.push(new m(e3, t3)), 1 !== s.length || f || c(d);\n}, m.prototype.run = function() {\n (this || r).fun.apply(null, (this || r).array);\n}, 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) {\n return [];\n}, o.binding = function(e3) {\n throw new Error(\"process.binding is not supported\");\n}, o.cwd = function() {\n return \"/\";\n}, o.chdir = function(e3) {\n throw new Error(\"process.chdir is not supported\");\n}, o.umask = function() {\n return 0;\n};\nvar T = e;\nT.addListener;\nT.argv;\nT.binding;\nT.browser;\nT.chdir;\nT.cwd;\nT.emit;\nT.env;\nT.listeners;\nT.nextTick;\nT.off;\nT.on;\nT.once;\nT.prependListener;\nT.prependOnceListener;\nT.removeAllListeners;\nT.removeListener;\nT.title;\nT.umask;\nT.version;\nT.versions;\n\n// node_modules/@jspm/core/nodelibs/browser/chunk-b4205b57.js\nvar t2 = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.toStringTag;\nvar e2 = Object.prototype.toString;\nvar o2 = function(o3) {\n return !(t2 && o3 && \"object\" == typeof o3 && Symbol.toStringTag in o3) && \"[object Arguments]\" === e2.call(o3);\n};\nvar n2 = function(t3) {\n 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);\n};\nvar r2 = function() {\n return o2(arguments);\n}();\no2.isLegacyArguments = n2;\nvar l2 = r2 ? o2 : n2;\nvar t$1 = Object.prototype.toString;\nvar o$1 = Function.prototype.toString;\nvar n$1 = /^\\s*(?:function)?\\*/;\nvar e$1 = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.toStringTag;\nvar r$1 = Object.getPrototypeOf;\nvar c2 = function() {\n if (!e$1)\n return false;\n try {\n return Function(\"return function*() {}\")();\n } catch (t3) {\n }\n}();\nvar u2 = c2 ? r$1(c2) : {};\nvar i2 = function(c3) {\n return \"function\" == typeof c3 && (!!n$1.test(o$1.call(c3)) || (e$1 ? r$1(c3) === u2 : \"[object GeneratorFunction]\" === t$1.call(c3)));\n};\nvar t$2 = \"function\" == typeof Object.create ? function(t3, e3) {\n e3 && (t3.super_ = e3, t3.prototype = Object.create(e3.prototype, { constructor: { value: t3, enumerable: false, writable: true, configurable: true } }));\n} : function(t3, e3) {\n if (e3) {\n t3.super_ = e3;\n var o3 = function() {\n };\n o3.prototype = e3.prototype, t3.prototype = new o3(), t3.prototype.constructor = t3;\n }\n};\nvar i$1 = function(e3) {\n return e3 && \"object\" == typeof e3 && \"function\" == typeof e3.copy && \"function\" == typeof e3.fill && \"function\" == typeof e3.readUInt8;\n};\nvar o$2 = {};\nvar u$1 = i$1;\nvar f2 = l2;\nvar a2 = i2;\nfunction c$1(e3) {\n return e3.call.bind(e3);\n}\nvar s2 = \"undefined\" != typeof BigInt;\nvar p2 = \"undefined\" != typeof Symbol;\nvar y = p2 && void 0 !== Symbol.toStringTag;\nvar l$1 = \"undefined\" != typeof Uint8Array;\nvar d2 = \"undefined\" != typeof ArrayBuffer;\nif (l$1 && y)\n var g = Object.getPrototypeOf(Uint8Array.prototype), b = c$1(Object.getOwnPropertyDescriptor(g, Symbol.toStringTag).get);\nvar m2 = c$1(Object.prototype.toString);\nvar h2 = c$1(Number.prototype.valueOf);\nvar j = c$1(String.prototype.valueOf);\nvar A = c$1(Boolean.prototype.valueOf);\nif (s2)\n var w = c$1(BigInt.prototype.valueOf);\nif (p2)\n var v = c$1(Symbol.prototype.valueOf);\nfunction O(e3, t3) {\n if (\"object\" != typeof e3)\n return false;\n try {\n return t3(e3), true;\n } catch (e4) {\n return false;\n }\n}\nfunction S(e3) {\n 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);\n}\nfunction B(e3) {\n return l$1 && y ? \"Uint8Array\" === b(e3) : \"[object Uint8Array]\" === m2(e3) || u$1(e3) && void 0 !== e3.buffer;\n}\nfunction k(e3) {\n return l$1 && y ? \"Uint8ClampedArray\" === b(e3) : \"[object Uint8ClampedArray]\" === m2(e3);\n}\nfunction E(e3) {\n return l$1 && y ? \"Uint16Array\" === b(e3) : \"[object Uint16Array]\" === m2(e3);\n}\nfunction D(e3) {\n return l$1 && y ? \"Uint32Array\" === b(e3) : \"[object Uint32Array]\" === m2(e3);\n}\nfunction U(e3) {\n return l$1 && y ? \"Int8Array\" === b(e3) : \"[object Int8Array]\" === m2(e3);\n}\nfunction P(e3) {\n return l$1 && y ? \"Int16Array\" === b(e3) : \"[object Int16Array]\" === m2(e3);\n}\nfunction x(e3) {\n return l$1 && y ? \"Int32Array\" === b(e3) : \"[object Int32Array]\" === m2(e3);\n}\nfunction I(e3) {\n return l$1 && y ? \"Float32Array\" === b(e3) : \"[object Float32Array]\" === m2(e3);\n}\nfunction M(e3) {\n return l$1 && y ? \"Float64Array\" === b(e3) : \"[object Float64Array]\" === m2(e3);\n}\nfunction z(e3) {\n return l$1 && y ? \"BigInt64Array\" === b(e3) : \"[object BigInt64Array]\" === m2(e3);\n}\nfunction F(e3) {\n return l$1 && y ? \"BigUint64Array\" === b(e3) : \"[object BigUint64Array]\" === m2(e3);\n}\nfunction T2(e3) {\n return \"[object Map]\" === m2(e3);\n}\nfunction N(e3) {\n return \"[object Set]\" === m2(e3);\n}\nfunction W(e3) {\n return \"[object WeakMap]\" === m2(e3);\n}\nfunction $(e3) {\n return \"[object WeakSet]\" === m2(e3);\n}\nfunction C(e3) {\n return \"[object ArrayBuffer]\" === m2(e3);\n}\nfunction V(e3) {\n return \"undefined\" != typeof ArrayBuffer && (C.working ? C(e3) : e3 instanceof ArrayBuffer);\n}\nfunction G(e3) {\n return \"[object DataView]\" === m2(e3);\n}\nfunction R(e3) {\n return \"undefined\" != typeof DataView && (G.working ? G(e3) : e3 instanceof DataView);\n}\nfunction J(e3) {\n return \"[object SharedArrayBuffer]\" === m2(e3);\n}\nfunction _(e3) {\n return \"undefined\" != typeof SharedArrayBuffer && (J.working ? J(e3) : e3 instanceof SharedArrayBuffer);\n}\nfunction H(e3) {\n return O(e3, h2);\n}\nfunction Z(e3) {\n return O(e3, j);\n}\nfunction q(e3) {\n return O(e3, A);\n}\nfunction K(e3) {\n return s2 && O(e3, w);\n}\nfunction L(e3) {\n return p2 && O(e3, v);\n}\no$2.isArgumentsObject = f2, o$2.isGeneratorFunction = a2, o$2.isPromise = function(e3) {\n return \"undefined\" != typeof Promise && e3 instanceof Promise || null !== e3 && \"object\" == typeof e3 && \"function\" == typeof e3.then && \"function\" == typeof e3.catch;\n}, o$2.isArrayBufferView = function(e3) {\n return d2 && ArrayBuffer.isView ? ArrayBuffer.isView(e3) : S(e3) || R(e3);\n}, 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) {\n return \"undefined\" != typeof Map && (T2.working ? T2(e3) : e3 instanceof Map);\n}, N.working = \"undefined\" != typeof Set && N(/* @__PURE__ */ new Set()), o$2.isSet = function(e3) {\n return \"undefined\" != typeof Set && (N.working ? N(e3) : e3 instanceof Set);\n}, W.working = \"undefined\" != typeof WeakMap && W(/* @__PURE__ */ new WeakMap()), o$2.isWeakMap = function(e3) {\n return \"undefined\" != typeof WeakMap && (W.working ? W(e3) : e3 instanceof WeakMap);\n}, $.working = \"undefined\" != typeof WeakSet && $(/* @__PURE__ */ new WeakSet()), o$2.isWeakSet = function(e3) {\n return $(e3);\n}, 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) {\n return \"[object AsyncFunction]\" === m2(e3);\n}, o$2.isMapIterator = function(e3) {\n return \"[object Map Iterator]\" === m2(e3);\n}, o$2.isSetIterator = function(e3) {\n return \"[object Set Iterator]\" === m2(e3);\n}, o$2.isGeneratorObject = function(e3) {\n return \"[object Generator]\" === m2(e3);\n}, o$2.isWebAssemblyCompiledModule = function(e3) {\n return \"[object WebAssembly.Module]\" === m2(e3);\n}, 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) {\n return H(e3) || Z(e3) || q(e3) || K(e3) || L(e3);\n}, o$2.isAnyArrayBuffer = function(e3) {\n return l$1 && (V(e3) || _(e3));\n}, [\"isProxy\", \"isExternal\", \"isModuleNamespaceObject\"].forEach(function(e3) {\n Object.defineProperty(o$2, e3, { enumerable: false, value: function() {\n throw new Error(e3 + \" is not supported in userland\");\n } });\n});\nvar Q = \"undefined\" != typeof globalThis ? globalThis : \"undefined\" != typeof self ? self : global;\nvar X = {};\nvar Y = T;\nvar ee = Object.getOwnPropertyDescriptors || function(e3) {\n for (var t3 = Object.keys(e3), r3 = {}, n3 = 0; n3 < t3.length; n3++)\n r3[t3[n3]] = Object.getOwnPropertyDescriptor(e3, t3[n3]);\n return r3;\n};\nvar te = /%[sdj%]/g;\nX.format = function(e3) {\n if (!ge(e3)) {\n for (var t3 = [], r3 = 0; r3 < arguments.length; r3++)\n t3.push(oe(arguments[r3]));\n return t3.join(\" \");\n }\n r3 = 1;\n for (var n3 = arguments, i3 = n3.length, o3 = String(e3).replace(te, function(e4) {\n if (\"%%\" === e4)\n return \"%\";\n if (r3 >= i3)\n return e4;\n switch (e4) {\n case \"%s\":\n return String(n3[r3++]);\n case \"%d\":\n return Number(n3[r3++]);\n case \"%j\":\n try {\n return JSON.stringify(n3[r3++]);\n } catch (e5) {\n return \"[Circular]\";\n }\n default:\n return e4;\n }\n }), u3 = n3[r3]; r3 < i3; u3 = n3[++r3])\n le(u3) || !he(u3) ? o3 += \" \" + u3 : o3 += \" \" + oe(u3);\n return o3;\n}, X.deprecate = function(e3, t3) {\n if (void 0 !== Y && true === Y.noDeprecation)\n return e3;\n if (void 0 === Y)\n return function() {\n return X.deprecate(e3, t3).apply(this || Q, arguments);\n };\n var r3 = false;\n return function() {\n if (!r3) {\n if (Y.throwDeprecation)\n throw new Error(t3);\n Y.traceDeprecation ? console.trace(t3) : console.error(t3), r3 = true;\n }\n return e3.apply(this || Q, arguments);\n };\n};\nvar re = {};\nvar ne = /^$/;\nif (Y.env.NODE_DEBUG) {\n ie = Y.env.NODE_DEBUG;\n ie = ie.replace(/[|\\\\{}()[\\]^$+?.]/g, \"\\\\$&\").replace(/\\*/g, \".*\").replace(/,/g, \"$|^\").toUpperCase(), ne = new RegExp(\"^\" + ie + \"$\", \"i\");\n}\nvar ie;\nfunction oe(e3, t3) {\n var r3 = { seen: [], stylize: fe };\n 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);\n}\nfunction ue(e3, t3) {\n var r3 = oe.styles[t3];\n return r3 ? \"\\x1B[\" + oe.colors[r3][0] + \"m\" + e3 + \"\\x1B[\" + oe.colors[r3][1] + \"m\" : e3;\n}\nfunction fe(e3, t3) {\n return e3;\n}\nfunction ae(e3, t3, r3) {\n if (e3.customInspect && t3 && we(t3.inspect) && t3.inspect !== X.inspect && (!t3.constructor || t3.constructor.prototype !== t3)) {\n var n3 = t3.inspect(r3, e3);\n return ge(n3) || (n3 = ae(e3, n3, r3)), n3;\n }\n var i3 = function(e4, t4) {\n if (be(t4))\n return e4.stylize(\"undefined\", \"undefined\");\n if (ge(t4)) {\n var r4 = \"'\" + JSON.stringify(t4).replace(/^\"|\"$/g, \"\").replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"') + \"'\";\n return e4.stylize(r4, \"string\");\n }\n if (de(t4))\n return e4.stylize(\"\" + t4, \"number\");\n if (ye(t4))\n return e4.stylize(\"\" + t4, \"boolean\");\n if (le(t4))\n return e4.stylize(\"null\", \"null\");\n }(e3, t3);\n if (i3)\n return i3;\n var o3 = Object.keys(t3), u3 = function(e4) {\n var t4 = {};\n return e4.forEach(function(e5, r4) {\n t4[e5] = true;\n }), t4;\n }(o3);\n if (e3.showHidden && (o3 = Object.getOwnPropertyNames(t3)), Ae(t3) && (o3.indexOf(\"message\") >= 0 || o3.indexOf(\"description\") >= 0))\n return ce(t3);\n if (0 === o3.length) {\n if (we(t3)) {\n var f3 = t3.name ? \": \" + t3.name : \"\";\n return e3.stylize(\"[Function\" + f3 + \"]\", \"special\");\n }\n if (me(t3))\n return e3.stylize(RegExp.prototype.toString.call(t3), \"regexp\");\n if (je(t3))\n return e3.stylize(Date.prototype.toString.call(t3), \"date\");\n if (Ae(t3))\n return ce(t3);\n }\n var a3, c3 = \"\", s3 = false, p3 = [\"{\", \"}\"];\n (pe(t3) && (s3 = true, p3 = [\"[\", \"]\"]), we(t3)) && (c3 = \" [Function\" + (t3.name ? \": \" + t3.name : \"\") + \"]\");\n 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 || s3 && 0 != t3.length ? r3 < 0 ? me(t3) ? e3.stylize(RegExp.prototype.toString.call(t3), \"regexp\") : e3.stylize(\"[Object]\", \"special\") : (e3.seen.push(t3), a3 = s3 ? function(e4, t4, r4, n4, i4) {\n for (var o4 = [], u4 = 0, f4 = t4.length; u4 < f4; ++u4)\n ke(t4, String(u4)) ? o4.push(se(e4, t4, r4, n4, String(u4), true)) : o4.push(\"\");\n return i4.forEach(function(i5) {\n i5.match(/^\\d+$/) || o4.push(se(e4, t4, r4, n4, i5, true));\n }), o4;\n }(e3, t3, r3, u3, o3) : o3.map(function(n4) {\n return se(e3, t3, r3, u3, n4, s3);\n }), e3.seen.pop(), function(e4, t4, r4) {\n var n4 = 0;\n if (e4.reduce(function(e5, t5) {\n return n4++, t5.indexOf(\"\\n\") >= 0 && n4++, e5 + t5.replace(/\\u001b\\[\\d\\d?m/g, \"\").length + 1;\n }, 0) > 60)\n return r4[0] + (\"\" === t4 ? \"\" : t4 + \"\\n \") + \" \" + e4.join(\",\\n \") + \" \" + r4[1];\n return r4[0] + t4 + \" \" + e4.join(\", \") + \" \" + r4[1];\n }(a3, c3, p3)) : p3[0] + c3 + p3[1];\n}\nfunction ce(e3) {\n return \"[\" + Error.prototype.toString.call(e3) + \"]\";\n}\nfunction se(e3, t3, r3, n3, i3, o3) {\n var u3, f3, a3;\n 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) {\n return \" \" + e4;\n }).join(\"\\n\").substr(2) : \"\\n\" + f3.split(\"\\n\").map(function(e4) {\n return \" \" + e4;\n }).join(\"\\n\")) : f3 = e3.stylize(\"[Circular]\", \"special\")), be(u3)) {\n if (o3 && i3.match(/^\\d+$/))\n return f3;\n (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\"));\n }\n return u3 + \": \" + f3;\n}\nfunction pe(e3) {\n return Array.isArray(e3);\n}\nfunction ye(e3) {\n return \"boolean\" == typeof e3;\n}\nfunction le(e3) {\n return null === e3;\n}\nfunction de(e3) {\n return \"number\" == typeof e3;\n}\nfunction ge(e3) {\n return \"string\" == typeof e3;\n}\nfunction be(e3) {\n return void 0 === e3;\n}\nfunction me(e3) {\n return he(e3) && \"[object RegExp]\" === ve(e3);\n}\nfunction he(e3) {\n return \"object\" == typeof e3 && null !== e3;\n}\nfunction je(e3) {\n return he(e3) && \"[object Date]\" === ve(e3);\n}\nfunction Ae(e3) {\n return he(e3) && (\"[object Error]\" === ve(e3) || e3 instanceof Error);\n}\nfunction we(e3) {\n return \"function\" == typeof e3;\n}\nfunction ve(e3) {\n return Object.prototype.toString.call(e3);\n}\nfunction Oe(e3) {\n return e3 < 10 ? \"0\" + e3.toString(10) : e3.toString(10);\n}\nX.debuglog = function(e3) {\n if (e3 = e3.toUpperCase(), !re[e3])\n if (ne.test(e3)) {\n var t3 = Y.pid;\n re[e3] = function() {\n var r3 = X.format.apply(X, arguments);\n console.error(\"%s %d: %s\", e3, t3, r3);\n };\n } else\n re[e3] = function() {\n };\n return re[e3];\n}, 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) {\n return null == e3;\n}, X.isNumber = de, X.isString = ge, X.isSymbol = function(e3) {\n return \"symbol\" == typeof e3;\n}, 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) {\n return null === e3 || \"boolean\" == typeof e3 || \"number\" == typeof e3 || \"string\" == typeof e3 || \"symbol\" == typeof e3 || void 0 === e3;\n}, X.isBuffer = i$1;\nvar Se = [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"];\nfunction Be() {\n var e3 = new Date(), t3 = [Oe(e3.getHours()), Oe(e3.getMinutes()), Oe(e3.getSeconds())].join(\":\");\n return [e3.getDate(), Se[e3.getMonth()], t3].join(\" \");\n}\nfunction ke(e3, t3) {\n return Object.prototype.hasOwnProperty.call(e3, t3);\n}\nX.log = function() {\n console.log(\"%s - %s\", Be(), X.format.apply(X, arguments));\n}, X.inherits = t$2, X._extend = function(e3, t3) {\n if (!t3 || !he(t3))\n return e3;\n for (var r3 = Object.keys(t3), n3 = r3.length; n3--; )\n e3[r3[n3]] = t3[r3[n3]];\n return e3;\n};\nvar Ee = \"undefined\" != typeof Symbol ? Symbol(\"util.promisify.custom\") : void 0;\nfunction De(e3, t3) {\n if (!e3) {\n var r3 = new Error(\"Promise was rejected with a falsy value\");\n r3.reason = e3, e3 = r3;\n }\n return t3(e3);\n}\nX.promisify = function(e3) {\n if (\"function\" != typeof e3)\n throw new TypeError('The \"original\" argument must be of type Function');\n if (Ee && e3[Ee]) {\n var t3;\n if (\"function\" != typeof (t3 = e3[Ee]))\n throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n return Object.defineProperty(t3, Ee, { value: t3, enumerable: false, writable: false, configurable: true }), t3;\n }\n function t3() {\n for (var t4, r3, n3 = new Promise(function(e4, n4) {\n t4 = e4, r3 = n4;\n }), i3 = [], o3 = 0; o3 < arguments.length; o3++)\n i3.push(arguments[o3]);\n i3.push(function(e4, n4) {\n e4 ? r3(e4) : t4(n4);\n });\n try {\n e3.apply(this || Q, i3);\n } catch (e4) {\n r3(e4);\n }\n return n3;\n }\n 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));\n}, X.promisify.custom = Ee, X.callbackify = function(e3) {\n if (\"function\" != typeof e3)\n throw new TypeError('The \"original\" argument must be of type Function');\n function t3() {\n for (var t4 = [], r3 = 0; r3 < arguments.length; r3++)\n t4.push(arguments[r3]);\n var n3 = t4.pop();\n if (\"function\" != typeof n3)\n throw new TypeError(\"The last argument must be of type Function\");\n var i3 = this || Q, o3 = function() {\n return n3.apply(i3, arguments);\n };\n e3.apply(this || Q, t4).then(function(e4) {\n Y.nextTick(o3.bind(null, null, e4));\n }, function(e4) {\n Y.nextTick(De.bind(null, e4, o3));\n });\n }\n return Object.setPrototypeOf(t3, Object.getPrototypeOf(e3)), Object.defineProperties(t3, ee(e3)), t3;\n};\n\n// node_modules/@jspm/core/nodelibs/browser/chunk-ce0fbc82.js\nX._extend;\nX.callbackify;\nX.debuglog;\nX.deprecate;\nX.format;\nX.inherits;\nX.inspect;\nX.isArray;\nX.isBoolean;\nX.isBuffer;\nX.isDate;\nX.isError;\nX.isFunction;\nX.isNull;\nX.isNullOrUndefined;\nX.isNumber;\nX.isObject;\nX.isPrimitive;\nX.isRegExp;\nX.isString;\nX.isSymbol;\nX.isUndefined;\nX.log;\nX.promisify;\nvar _extend = X._extend;\nvar callbackify = X.callbackify;\nvar debuglog = X.debuglog;\nvar deprecate = X.deprecate;\nvar format = X.format;\nvar inherits = X.inherits;\nvar inspect = X.inspect;\nvar isArray = X.isArray;\nvar isBoolean = X.isBoolean;\nvar isBuffer = X.isBuffer;\nvar isDate = X.isDate;\nvar isError = X.isError;\nvar isFunction = X.isFunction;\nvar isNull = X.isNull;\nvar isNullOrUndefined = X.isNullOrUndefined;\nvar isNumber = X.isNumber;\nvar isObject = X.isObject;\nvar isPrimitive = X.isPrimitive;\nvar isRegExp = X.isRegExp;\nvar isString = X.isString;\nvar isSymbol = X.isSymbol;\nvar isUndefined = X.isUndefined;\nvar log = X.log;\nvar promisify = X.promisify;\nvar types = X.types;\nvar TextEncoder = self.TextEncoder;\nvar TextDecoder = self.TextDecoder;\n\n// node_modules/@jspm/core/nodelibs/browser/util.js\nvar _extend2 = X._extend;\nvar callbackify2 = X.callbackify;\nvar debuglog2 = X.debuglog;\nvar deprecate2 = X.deprecate;\nvar format2 = X.format;\nvar inherits2 = X.inherits;\nvar inspect2 = X.inspect;\nvar isArray2 = X.isArray;\nvar isBoolean2 = X.isBoolean;\nvar isBuffer2 = X.isBuffer;\nvar isDate2 = X.isDate;\nvar isError2 = X.isError;\nvar isFunction2 = X.isFunction;\nvar isNull2 = X.isNull;\nvar isNullOrUndefined2 = X.isNullOrUndefined;\nvar isNumber2 = X.isNumber;\nvar isObject2 = X.isObject;\nvar isPrimitive2 = X.isPrimitive;\nvar isRegExp2 = X.isRegExp;\nvar isString2 = X.isString;\nvar isSymbol2 = X.isSymbol;\nvar isUndefined2 = X.isUndefined;\nvar log2 = X.log;\nvar promisify2 = X.promisify;\nvar types2 = X.types;\nvar TextEncoder2 = X.TextEncoder = globalThis.TextEncoder;\nvar TextDecoder2 = X.TextDecoder = globalThis.TextDecoder;\nexport {\n TextDecoder2 as TextDecoder,\n TextEncoder2 as TextEncoder,\n _extend2 as _extend,\n callbackify2 as callbackify,\n debuglog2 as debuglog,\n X as default,\n deprecate2 as deprecate,\n format2 as format,\n inherits2 as inherits,\n inspect2 as inspect,\n isArray2 as isArray,\n isBoolean2 as isBoolean,\n isBuffer2 as isBuffer,\n isDate2 as isDate,\n isError2 as isError,\n isFunction2 as isFunction,\n isNull2 as isNull,\n isNullOrUndefined2 as isNullOrUndefined,\n isNumber2 as isNumber,\n isObject2 as isObject,\n isPrimitive2 as isPrimitive,\n isRegExp2 as isRegExp,\n isString2 as isString,\n isSymbol2 as isSymbol,\n isUndefined2 as isUndefined,\n log2 as log,\n promisify2 as promisify,\n types2 as types\n};\n","import type { InspectOptionsStylized } from 'util';\n\nexport const customInspectSymbol = Symbol.for('nodejs.util.inspect.custom');\nexport const customInspectSymbolStackLess = Symbol.for('nodejs.util.inspect.custom.stack-less');\n\nexport abstract class BaseError extends Error {\n\tprotected [customInspectSymbol](depth: number, options: InspectOptionsStylized) {\n\t\treturn `${this[customInspectSymbolStackLess](depth, options)}\\n${this.stack!.slice(this.stack!.indexOf('\\n'))}`;\n\t}\n\n\tprotected abstract [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string;\n}\n","import type {\n\tArrayConstraintName,\n\tBigIntConstraintName,\n\tBooleanConstraintName,\n\tDateConstraintName,\n\tNumberConstraintName,\n\tObjectConstraintName,\n\tStringConstraintName,\n\tTypedArrayConstraintName\n} from '../../constraints/type-exports';\nimport { BaseError } from './BaseError';\n\nexport type ConstraintErrorNames =\n\t| TypedArrayConstraintName\n\t| ArrayConstraintName\n\t| BigIntConstraintName\n\t| BooleanConstraintName\n\t| DateConstraintName\n\t| NumberConstraintName\n\t| ObjectConstraintName\n\t| StringConstraintName;\n\nexport abstract class BaseConstraintError<T = unknown> extends BaseError {\n\tpublic readonly constraint: ConstraintErrorNames;\n\tpublic readonly given: T;\n\n\tpublic constructor(constraint: ConstraintErrorNames, message: string, given: T) {\n\t\tsuper(message);\n\t\tthis.constraint = constraint;\n\t\tthis.given = given;\n\t}\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { customInspectSymbolStackLess } from './BaseError';\nimport { BaseConstraintError, type ConstraintErrorNames } from './BaseConstraintError';\n\nexport class ExpectedConstraintError<T = unknown> extends BaseConstraintError<T> {\n\tpublic readonly expected: string;\n\n\tpublic constructor(constraint: ConstraintErrorNames, message: string, given: T, expected: string) {\n\t\tsuper(constraint, message, given);\n\t\tthis.expected = expected;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tconstraint: this.constraint,\n\t\t\tgiven: this.given,\n\t\t\texpected: this.expected\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst constraint = options.stylize(this.constraint, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[ExpectedConstraintError: ${constraint}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1 };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('ExpectedConstraintError', 'special')} > ${constraint}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst expectedBlock = `\\n ${options.stylize('Expected: ', 'string')}${options.stylize(this.expected, 'boolean')}`;\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${expectedBlock}\\n${givenBlock}`;\n\t}\n}\n","import { getGlobalValidationEnabled } from '../lib/configs';\nimport { Result } from '../lib/Result';\nimport { ArrayValidator, DefaultValidator, LiteralValidator, NullishValidator, SetValidator, UnionValidator } from './imports';\nimport { getValue } from './util/getValue';\nimport { whenConstraint, type WhenKey, type WhenOptions } from '../constraints/ObjectConstrains';\nimport type { CombinedError } from '../lib/errors/CombinedError';\nimport type { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport type { UnknownEnumValueError } from '../lib/errors/UnknownEnumValueError';\nimport type { ValidationError } from '../lib/errors/ValidationError';\nimport type { BaseConstraintError, InferResultType } from '../type-exports';\nimport type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\n\nexport abstract class BaseValidator<T> {\n\tpublic description?: string;\n\tprotected parent?: object;\n\tprotected constraints: readonly IConstraint<T>[] = [];\n\tprotected isValidationEnabled: boolean | (() => boolean) | null = null;\n\n\tpublic constructor(constraints: readonly IConstraint<T>[] = []) {\n\t\tthis.constraints = constraints;\n\t}\n\n\tpublic setParent(parent: object): this {\n\t\tthis.parent = parent;\n\t\treturn this;\n\t}\n\n\tpublic get optional(): UnionValidator<T | undefined> {\n\t\treturn new UnionValidator([new LiteralValidator(undefined), this.clone()]);\n\t}\n\n\tpublic get nullable(): UnionValidator<T | null> {\n\t\treturn new UnionValidator([new LiteralValidator(null), this.clone()]);\n\t}\n\n\tpublic get nullish(): UnionValidator<T | null | undefined> {\n\t\treturn new UnionValidator([new NullishValidator(), this.clone()]);\n\t}\n\n\tpublic get array(): ArrayValidator<T[]> {\n\t\treturn new ArrayValidator<T[]>(this.clone());\n\t}\n\n\tpublic get set(): SetValidator<T> {\n\t\treturn new SetValidator<T>(this.clone());\n\t}\n\n\tpublic or<O>(...predicates: readonly BaseValidator<O>[]): UnionValidator<T | O> {\n\t\treturn new UnionValidator<T | O>([this.clone(), ...predicates]);\n\t}\n\n\tpublic transform(cb: (value: T) => T): this;\n\tpublic transform<O>(cb: (value: T) => O): BaseValidator<O>;\n\tpublic transform<O>(cb: (value: T) => O): BaseValidator<O> {\n\t\treturn this.addConstraint({ run: (input) => Result.ok(cb(input) as unknown as T) }) as unknown as BaseValidator<O>;\n\t}\n\n\tpublic reshape(cb: (input: T) => Result<T>): this;\n\tpublic reshape<R extends Result<unknown>, O = InferResultType<R>>(cb: (input: T) => R): BaseValidator<O>;\n\tpublic reshape<R extends Result<unknown>, O = InferResultType<R>>(cb: (input: T) => R): BaseValidator<O> {\n\t\treturn this.addConstraint({ run: cb as unknown as (input: T) => Result<T, BaseConstraintError<T>> }) as unknown as BaseValidator<O>;\n\t}\n\n\tpublic default(value: Exclude<T, undefined> | (() => Exclude<T, undefined>)): DefaultValidator<Exclude<T, undefined>> {\n\t\treturn new DefaultValidator(this.clone() as unknown as BaseValidator<Exclude<T, undefined>>, value);\n\t}\n\n\tpublic when<Key extends WhenKey, This extends BaseValidator<any> = this>(key: Key, options: WhenOptions<This, Key>): this {\n\t\treturn this.addConstraint(whenConstraint<This, T, Key>(key, options, this as unknown as This));\n\t}\n\n\tpublic describe(description: string): this {\n\t\tconst clone = this.clone();\n\t\tclone.description = description;\n\t\treturn clone;\n\t}\n\n\tpublic run(value: unknown): Result<T, BaseError> {\n\t\tlet result = this.handle(value) as Result<T, BaseError>;\n\t\tif (result.isErr()) return result;\n\n\t\tfor (const constraint of this.constraints) {\n\t\t\tresult = constraint.run(result.value as T, this.parent);\n\t\t\tif (result.isErr()) break;\n\t\t}\n\n\t\treturn result;\n\t}\n\n\tpublic parse<R extends T = T>(value: unknown): R {\n\t\t// If validation is disabled (at the validator or global level), we only run the `handle` method, which will do some basic checks\n\t\t// (like that the input is a string for a string validator)\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn this.handle(value).unwrap() as R;\n\t\t}\n\n\t\treturn this.constraints.reduce((v, constraint) => constraint.run(v).unwrap(), this.handle(value).unwrap()) as R;\n\t}\n\n\tpublic is<R extends T = T>(value: unknown): value is R {\n\t\treturn this.run(value).isOk();\n\t}\n\n\t/**\n\t * Sets if the validator should also run constraints or just do basic checks.\n\t * @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.\n\t * Set to `null` to go off of the global configuration.\n\t */\n\tpublic setValidationEnabled(isValidationEnabled: boolean | (() => boolean) | null): this {\n\t\tconst clone = this.clone();\n\t\tclone.isValidationEnabled = isValidationEnabled;\n\t\treturn clone;\n\t}\n\n\tpublic getValidationEnabled() {\n\t\treturn getValue(this.isValidationEnabled);\n\t}\n\n\tprotected get shouldRunConstraints(): boolean {\n\t\treturn getValue(this.isValidationEnabled) ?? getGlobalValidationEnabled();\n\t}\n\n\tprotected clone(): this {\n\t\tconst clone: this = Reflect.construct(this.constructor, [this.constraints]);\n\t\tclone.isValidationEnabled = this.isValidationEnabled;\n\t\treturn clone;\n\t}\n\n\tprotected abstract handle(value: unknown): Result<T, ValidatorError>;\n\n\tprotected addConstraint(constraint: IConstraint<T>): this {\n\t\tconst clone = this.clone();\n\t\tclone.constraints = clone.constraints.concat(constraint);\n\t\treturn clone;\n\t}\n}\n\nexport type ValidatorError = ValidationError | CombinedError | CombinedPropertyError | UnknownEnumValueError;\n","import fastDeepEqual from 'fast-deep-equal/es6/index.js';\nimport uniqWith from 'lodash/uniqWith.js';\n\nexport function isUnique(input: unknown[]) {\n\tif (input.length < 2) return true;\n\tconst uniqueArray = uniqWith(input, fastDeepEqual);\n\treturn uniqueArray.length === input.length;\n}\n","export function lessThan(a: number, b: number): boolean;\nexport function lessThan(a: bigint, b: bigint): boolean;\nexport function lessThan(a: number | bigint, b: number | bigint): boolean {\n\treturn a < b;\n}\n\nexport function lessThanOrEqual(a: number, b: number): boolean;\nexport function lessThanOrEqual(a: bigint, b: bigint): boolean;\nexport function lessThanOrEqual(a: number | bigint, b: number | bigint): boolean {\n\treturn a <= b;\n}\n\nexport function greaterThan(a: number, b: number): boolean;\nexport function greaterThan(a: bigint, b: bigint): boolean;\nexport function greaterThan(a: number | bigint, b: number | bigint): boolean {\n\treturn a > b;\n}\n\nexport function greaterThanOrEqual(a: number, b: number): boolean;\nexport function greaterThanOrEqual(a: bigint, b: bigint): boolean;\nexport function greaterThanOrEqual(a: number | bigint, b: number | bigint): boolean {\n\treturn a >= b;\n}\n\nexport function equal(a: number, b: number): boolean;\nexport function equal(a: bigint, b: bigint): boolean;\nexport function equal(a: number | bigint, b: number | bigint): boolean {\n\treturn a === b;\n}\n\nexport function notEqual(a: number, b: number): boolean;\nexport function notEqual(a: bigint, b: bigint): boolean;\nexport function notEqual(a: number | bigint, b: number | bigint): boolean {\n\treturn a !== b;\n}\n\nexport interface Comparator {\n\t(a: number, b: number): boolean;\n\t(a: bigint, b: bigint): boolean;\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { isUnique } from './util/isUnique';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type ArrayConstraintName = `s.array(T).${\n\t| 'unique'\n\t| `length${\n\t\t\t| 'LessThan'\n\t\t\t| 'LessThanOrEqual'\n\t\t\t| 'GreaterThan'\n\t\t\t| 'GreaterThanOrEqual'\n\t\t\t| 'Equal'\n\t\t\t| 'NotEqual'\n\t\t\t| 'Range'\n\t\t\t| 'RangeInclusive'\n\t\t\t| 'RangeExclusive'}`}`;\n\nfunction arrayLengthComparator<T>(comparator: Comparator, name: ArrayConstraintName, expected: string, length: number): IConstraint<T[]> {\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn comparator(input.length, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function arrayLengthLessThan<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length < ${value}`;\n\treturn arrayLengthComparator(lessThan, 's.array(T).lengthLessThan', expected, value);\n}\n\nexport function arrayLengthLessThanOrEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length <= ${value}`;\n\treturn arrayLengthComparator(lessThanOrEqual, 's.array(T).lengthLessThanOrEqual', expected, value);\n}\n\nexport function arrayLengthGreaterThan<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length > ${value}`;\n\treturn arrayLengthComparator(greaterThan, 's.array(T).lengthGreaterThan', expected, value);\n}\n\nexport function arrayLengthGreaterThanOrEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length >= ${value}`;\n\treturn arrayLengthComparator(greaterThanOrEqual, 's.array(T).lengthGreaterThanOrEqual', expected, value);\n}\n\nexport function arrayLengthEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length === ${value}`;\n\treturn arrayLengthComparator(equal, 's.array(T).lengthEqual', expected, value);\n}\n\nexport function arrayLengthNotEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length !== ${value}`;\n\treturn arrayLengthComparator(notEqual, 's.array(T).lengthNotEqual', expected, value);\n}\n\nexport function arrayLengthRange<T>(start: number, endBefore: number): IConstraint<T[]> {\n\tconst expected = `expected.length >= ${start} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn input.length >= start && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).lengthRange', 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function arrayLengthRangeInclusive<T>(start: number, end: number): IConstraint<T[]> {\n\tconst expected = `expected.length >= ${start} && expected.length <= ${end}`;\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn input.length >= start && input.length <= end //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).lengthRangeInclusive', 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function arrayLengthRangeExclusive<T>(startAfter: number, endBefore: number): IConstraint<T[]> {\n\tconst expected = `expected.length > ${startAfter} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn input.length > startAfter && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).lengthRangeExclusive', 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport const uniqueArray: IConstraint<unknown[]> = {\n\trun(input: unknown[]) {\n\t\treturn isUnique(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).unique', 'Array values are not unique', input, 'Expected all values to be unique'));\n\t}\n};\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class CombinedPropertyError extends BaseError {\n\tpublic readonly errors: [PropertyKey, BaseError][];\n\n\tpublic constructor(errors: [PropertyKey, BaseError][]) {\n\t\tsuper('Received one or more errors');\n\n\t\tthis.errors = errors;\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize('[CombinedPropertyError]', 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\n\t\tconst header = `${options.stylize('CombinedPropertyError', 'special')} (${options.stylize(this.errors.length.toString(), 'number')})`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst errors = this.errors\n\t\t\t.map(([key, error]) => {\n\t\t\t\tconst property = CombinedPropertyError.formatProperty(key, options);\n\t\t\t\tconst body = error[customInspectSymbolStackLess](depth - 1, newOptions).replace(/\\n/g, padding);\n\n\t\t\t\treturn ` input${property}${padding}${body}`;\n\t\t\t})\n\t\t\t.join('\\n\\n');\n\t\treturn `${header}\\n ${message}\\n\\n${errors}`;\n\t}\n\n\tprivate static formatProperty(key: PropertyKey, options: InspectOptionsStylized): string {\n\t\tif (typeof key === 'string') return options.stylize(`.${key}`, 'symbol');\n\t\tif (typeof key === 'number') return `[${options.stylize(key.toString(), 'number')}]`;\n\t\treturn `[${options.stylize('Symbol', 'symbol')}(${key.description})]`;\n\t}\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class ValidationError extends BaseError {\n\tpublic readonly validator: string;\n\tpublic readonly given: unknown;\n\n\tpublic constructor(validator: string, message: string, given: unknown) {\n\t\tsuper(message);\n\n\t\tthis.validator = validator;\n\t\tthis.given = given;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tvalidator: this.validator,\n\t\t\tgiven: this.given\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst validator = options.stylize(this.validator, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[ValidationError: ${validator}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('ValidationError', 'special')} > ${validator}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${givenBlock}`;\n\t}\n}\n","import {\n\tarrayLengthEqual,\n\tarrayLengthGreaterThan,\n\tarrayLengthGreaterThanOrEqual,\n\tarrayLengthLessThan,\n\tarrayLengthLessThanOrEqual,\n\tarrayLengthNotEqual,\n\tarrayLengthRange,\n\tarrayLengthRangeExclusive,\n\tarrayLengthRangeInclusive,\n\tuniqueArray\n} from '../constraints/ArrayConstraints';\nimport type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport type { ExpandSmallerTuples, Tuple, UnshiftTuple } from '../lib/util-types';\nimport { BaseValidator } from './imports';\n\nexport class ArrayValidator<T extends unknown[], I = T[number]> extends BaseValidator<T> {\n\tprivate readonly validator: BaseValidator<I>;\n\n\tpublic constructor(validator: BaseValidator<I>, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tpublic lengthLessThan<N extends number>(length: N): ArrayValidator<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, N>]>>> {\n\t\treturn this.addConstraint(arrayLengthLessThan(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthLessThanOrEqual<N extends number>(length: N): ArrayValidator<ExpandSmallerTuples<[...Tuple<I, N>]>> {\n\t\treturn this.addConstraint(arrayLengthLessThanOrEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthGreaterThan<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>, I, ...T]> {\n\t\treturn this.addConstraint(arrayLengthGreaterThan(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthGreaterThanOrEqual<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>, ...T]> {\n\t\treturn this.addConstraint(arrayLengthGreaterThanOrEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthEqual<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>]> {\n\t\treturn this.addConstraint(arrayLengthEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthNotEqual(length: number): ArrayValidator<[...T]> {\n\t\treturn this.addConstraint(arrayLengthNotEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthRange<S extends number, E extends number>(\n\t\tstart: S,\n\t\tendBefore: E\n\t): ArrayValidator<Exclude<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, E>]>>, ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, S>]>>>> {\n\t\treturn this.addConstraint(arrayLengthRange(start, endBefore) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthRangeInclusive<S extends number, E extends number>(\n\t\tstartAt: S,\n\t\tendAt: E\n\t): ArrayValidator<Exclude<ExpandSmallerTuples<[...Tuple<I, E>]>, ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, S>]>>>> {\n\t\treturn this.addConstraint(arrayLengthRangeInclusive(startAt, endAt) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthRangeExclusive<S extends number, E extends number>(\n\t\tstartAfter: S,\n\t\tendBefore: E\n\t): ArrayValidator<Exclude<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, E>]>>, ExpandSmallerTuples<[...Tuple<T, S>]>>> {\n\t\treturn this.addConstraint(arrayLengthRangeExclusive(startAfter, endBefore) as IConstraint<T>) as any;\n\t}\n\n\tpublic get unique(): this {\n\t\treturn this.addConstraint(uniqueArray as IConstraint<T>);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<T, ValidationError | CombinedPropertyError> {\n\t\tif (!Array.isArray(values)) {\n\t\t\treturn Result.err(new ValidationError('s.array(T)', 'Expected an array', values));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(values as T);\n\t\t}\n\n\t\tconst errors: [number, BaseError][] = [];\n\t\tconst transformed: T = [] as unknown as T;\n\n\t\tfor (let i = 0; i < values.length; i++) {\n\t\t\tconst result = this.validator.run(values[i]);\n\t\t\tif (result.isOk()) transformed.push(result.value);\n\t\t\telse errors.push([i, result.error!]);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type BigIntConstraintName = `s.bigint.${\n\t| 'lessThan'\n\t| 'lessThanOrEqual'\n\t| 'greaterThan'\n\t| 'greaterThanOrEqual'\n\t| 'equal'\n\t| 'notEqual'\n\t| 'divisibleBy'}`;\n\nfunction bigintComparator(comparator: Comparator, name: BigIntConstraintName, expected: string, number: bigint): IConstraint<bigint> {\n\treturn {\n\t\trun(input: bigint) {\n\t\t\treturn comparator(input, number) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid bigint value', input, expected));\n\t\t}\n\t};\n}\n\nexport function bigintLessThan(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected < ${value}n`;\n\treturn bigintComparator(lessThan, 's.bigint.lessThan', expected, value);\n}\n\nexport function bigintLessThanOrEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected <= ${value}n`;\n\treturn bigintComparator(lessThanOrEqual, 's.bigint.lessThanOrEqual', expected, value);\n}\n\nexport function bigintGreaterThan(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected > ${value}n`;\n\treturn bigintComparator(greaterThan, 's.bigint.greaterThan', expected, value);\n}\n\nexport function bigintGreaterThanOrEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected >= ${value}n`;\n\treturn bigintComparator(greaterThanOrEqual, 's.bigint.greaterThanOrEqual', expected, value);\n}\n\nexport function bigintEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected === ${value}n`;\n\treturn bigintComparator(equal, 's.bigint.equal', expected, value);\n}\n\nexport function bigintNotEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected !== ${value}n`;\n\treturn bigintComparator(notEqual, 's.bigint.notEqual', expected, value);\n}\n\nexport function bigintDivisibleBy(divider: bigint): IConstraint<bigint> {\n\tconst expected = `expected % ${divider}n === 0n`;\n\treturn {\n\t\trun(input: bigint) {\n\t\t\treturn input % divider === 0n //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.bigint.divisibleBy', 'BigInt is not divisible', input, expected));\n\t\t}\n\t};\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\tbigintDivisibleBy,\n\tbigintEqual,\n\tbigintGreaterThan,\n\tbigintGreaterThanOrEqual,\n\tbigintLessThan,\n\tbigintLessThanOrEqual,\n\tbigintNotEqual\n} from '../constraints/BigIntConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class BigIntValidator<T extends bigint> extends BaseValidator<T> {\n\tpublic lessThan(number: bigint): this {\n\t\treturn this.addConstraint(bigintLessThan(number) as IConstraint<T>);\n\t}\n\n\tpublic lessThanOrEqual(number: bigint): this {\n\t\treturn this.addConstraint(bigintLessThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThan(number: bigint): this {\n\t\treturn this.addConstraint(bigintGreaterThan(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThanOrEqual(number: bigint): this {\n\t\treturn this.addConstraint(bigintGreaterThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic equal<N extends bigint>(number: N): BigIntValidator<N> {\n\t\treturn this.addConstraint(bigintEqual(number) as IConstraint<T>) as unknown as BigIntValidator<N>;\n\t}\n\n\tpublic notEqual(number: bigint): this {\n\t\treturn this.addConstraint(bigintNotEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic get positive(): this {\n\t\treturn this.greaterThanOrEqual(0n);\n\t}\n\n\tpublic get negative(): this {\n\t\treturn this.lessThan(0n);\n\t}\n\n\tpublic divisibleBy(number: bigint): this {\n\t\treturn this.addConstraint(bigintDivisibleBy(number) as IConstraint<T>);\n\t}\n\n\tpublic get abs(): this {\n\t\treturn this.transform((value) => (value < 0 ? -value : value) as T);\n\t}\n\n\tpublic intN(bits: number): this {\n\t\treturn this.transform((value) => BigInt.asIntN(bits, value) as T);\n\t}\n\n\tpublic uintN(bits: number): this {\n\t\treturn this.transform((value) => BigInt.asUintN(bits, value) as T);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'bigint' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.bigint', 'Expected a bigint primitive', value));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\n\nexport type BooleanConstraintName = `s.boolean.${boolean}`;\n\nexport const booleanTrue: IConstraint<boolean, true> = {\n\trun(input: boolean) {\n\t\treturn input //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.boolean.true', 'Invalid boolean value', input, 'true'));\n\t}\n};\n\nexport const booleanFalse: IConstraint<boolean, false> = {\n\trun(input: boolean) {\n\t\treturn input //\n\t\t\t? Result.err(new ExpectedConstraintError('s.boolean.false', 'Invalid boolean value', input, 'false'))\n\t\t\t: Result.ok(input);\n\t}\n};\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { booleanFalse, booleanTrue } from '../constraints/BooleanConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class BooleanValidator<T extends boolean = boolean> extends BaseValidator<T> {\n\tpublic get true(): BooleanValidator<true> {\n\t\treturn this.addConstraint(booleanTrue as IConstraint<T>) as BooleanValidator<true>;\n\t}\n\n\tpublic get false(): BooleanValidator<false> {\n\t\treturn this.addConstraint(booleanFalse as IConstraint<T>) as BooleanValidator<false>;\n\t}\n\n\tpublic equal<R extends true | false>(value: R): BooleanValidator<R> {\n\t\treturn (value ? this.true : this.false) as BooleanValidator<R>;\n\t}\n\n\tpublic notEqual<R extends true | false>(value: R): BooleanValidator<R> {\n\t\treturn (value ? this.false : this.true) as BooleanValidator<R>;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'boolean' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.boolean', 'Expected a boolean primitive', value));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type DateConstraintName = `s.date.${\n\t| 'lessThan'\n\t| 'lessThanOrEqual'\n\t| 'greaterThan'\n\t| 'greaterThanOrEqual'\n\t| 'equal'\n\t| 'notEqual'\n\t| 'valid'\n\t| 'invalid'}`;\n\nfunction dateComparator(comparator: Comparator, name: DateConstraintName, expected: string, number: number): IConstraint<Date> {\n\treturn {\n\t\trun(input: Date) {\n\t\t\treturn comparator(input.getTime(), number) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Date value', input, expected));\n\t\t}\n\t};\n}\n\nexport function dateLessThan(value: Date): IConstraint<Date> {\n\tconst expected = `expected < ${value.toISOString()}`;\n\treturn dateComparator(lessThan, 's.date.lessThan', expected, value.getTime());\n}\n\nexport function dateLessThanOrEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected <= ${value.toISOString()}`;\n\treturn dateComparator(lessThanOrEqual, 's.date.lessThanOrEqual', expected, value.getTime());\n}\n\nexport function dateGreaterThan(value: Date): IConstraint<Date> {\n\tconst expected = `expected > ${value.toISOString()}`;\n\treturn dateComparator(greaterThan, 's.date.greaterThan', expected, value.getTime());\n}\n\nexport function dateGreaterThanOrEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected >= ${value.toISOString()}`;\n\treturn dateComparator(greaterThanOrEqual, 's.date.greaterThanOrEqual', expected, value.getTime());\n}\n\nexport function dateEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected === ${value.toISOString()}`;\n\treturn dateComparator(equal, 's.date.equal', expected, value.getTime());\n}\n\nexport function dateNotEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected !== ${value.toISOString()}`;\n\treturn dateComparator(notEqual, 's.date.notEqual', expected, value.getTime());\n}\n\nexport const dateInvalid: IConstraint<Date> = {\n\trun(input: Date) {\n\t\treturn Number.isNaN(input.getTime()) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.date.invalid', 'Invalid Date value', input, 'expected === NaN'));\n\t}\n};\n\nexport const dateValid: IConstraint<Date> = {\n\trun(input: Date) {\n\t\treturn Number.isNaN(input.getTime()) //\n\t\t\t? Result.err(new ExpectedConstraintError('s.date.valid', 'Invalid Date value', input, 'expected !== NaN'))\n\t\t\t: Result.ok(input);\n\t}\n};\n","import {\n\tdateEqual,\n\tdateGreaterThan,\n\tdateGreaterThanOrEqual,\n\tdateInvalid,\n\tdateLessThan,\n\tdateLessThanOrEqual,\n\tdateNotEqual,\n\tdateValid\n} from '../constraints/DateConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class DateValidator extends BaseValidator<Date> {\n\tpublic lessThan(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateLessThan(new Date(date)));\n\t}\n\n\tpublic lessThanOrEqual(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateLessThanOrEqual(new Date(date)));\n\t}\n\n\tpublic greaterThan(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateGreaterThan(new Date(date)));\n\t}\n\n\tpublic greaterThanOrEqual(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateGreaterThanOrEqual(new Date(date)));\n\t}\n\n\tpublic equal(date: Date | number | string): this {\n\t\tconst resolved = new Date(date);\n\t\treturn Number.isNaN(resolved.getTime()) //\n\t\t\t? this.invalid\n\t\t\t: this.addConstraint(dateEqual(resolved));\n\t}\n\n\tpublic notEqual(date: Date | number | string): this {\n\t\tconst resolved = new Date(date);\n\t\treturn Number.isNaN(resolved.getTime()) //\n\t\t\t? this.valid\n\t\t\t: this.addConstraint(dateNotEqual(resolved));\n\t}\n\n\tpublic get valid(): this {\n\t\treturn this.addConstraint(dateValid);\n\t}\n\n\tpublic get invalid(): this {\n\t\treturn this.addConstraint(dateInvalid);\n\t}\n\n\tprotected handle(value: unknown): Result<Date, ValidationError> {\n\t\treturn value instanceof Date //\n\t\t\t? Result.ok(value)\n\t\t\t: Result.err(new ValidationError('s.date', 'Expected a Date', value));\n\t}\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { customInspectSymbolStackLess } from './BaseError';\nimport { ValidationError } from './ValidationError';\n\nexport class ExpectedValidationError<T> extends ValidationError {\n\tpublic readonly expected: T;\n\n\tpublic constructor(validator: string, message: string, given: unknown, expected: T) {\n\t\tsuper(validator, message, given);\n\t\tthis.expected = expected;\n\t}\n\n\tpublic override toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tvalidator: this.validator,\n\t\t\tgiven: this.given,\n\t\t\texpected: this.expected\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst validator = options.stylize(this.validator, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[ExpectedValidationError: ${validator}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1 };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst expected = inspect(this.expected, newOptions).replace(/\\n/g, padding);\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('ExpectedValidationError', 'special')} > ${validator}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst expectedBlock = `\\n ${options.stylize('Expected:', 'string')}${padding}${expected}`;\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${expectedBlock}\\n${givenBlock}`;\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { ExpectedValidationError } from '../lib/errors/ExpectedValidationError';\nimport { Result } from '../lib/Result';\nimport type { Constructor } from '../lib/util-types';\nimport { BaseValidator } from './imports';\n\nexport class InstanceValidator<T> extends BaseValidator<T> {\n\tpublic readonly expected: Constructor<T>;\n\n\tpublic constructor(expected: Constructor<T>, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.expected = expected;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ExpectedValidationError<Constructor<T>>> {\n\t\treturn value instanceof this.expected //\n\t\t\t? Result.ok(value)\n\t\t\t: Result.err(new ExpectedValidationError('s.instance(V)', 'Expected', value, this.expected));\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.expected, this.constraints]);\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { ExpectedValidationError } from '../lib/errors/ExpectedValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class LiteralValidator<T> extends BaseValidator<T> {\n\tpublic readonly expected: T;\n\n\tpublic constructor(literal: T, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.expected = literal;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ExpectedValidationError<T>> {\n\t\treturn Object.is(value, this.expected) //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ExpectedValidationError('s.literal(V)', 'Expected values to be equals', value, this.expected));\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.expected, this.constraints]);\n\t}\n}\n","import { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NeverValidator extends BaseValidator<never> {\n\tprotected handle(value: unknown): Result<never, ValidationError> {\n\t\treturn Result.err(new ValidationError('s.never', 'Expected a value to not be passed', value));\n\t}\n}\n","import { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NullishValidator extends BaseValidator<undefined | null> {\n\tprotected handle(value: unknown): Result<undefined | null, ValidationError> {\n\t\treturn value === undefined || value === null //\n\t\t\t? Result.ok(value)\n\t\t\t: Result.err(new ValidationError('s.nullish', 'Expected undefined or null', value));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type NumberConstraintName = `s.number.${\n\t| 'lessThan'\n\t| 'lessThanOrEqual'\n\t| 'greaterThan'\n\t| 'greaterThanOrEqual'\n\t| 'equal'\n\t| 'equal(NaN)'\n\t| 'notEqual'\n\t| 'notEqual(NaN)'\n\t| 'int'\n\t| 'safeInt'\n\t| 'finite'\n\t| 'divisibleBy'}`;\n\nfunction numberComparator(comparator: Comparator, name: NumberConstraintName, expected: string, number: number): IConstraint<number> {\n\treturn {\n\t\trun(input: number) {\n\t\t\treturn comparator(input, number) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid number value', input, expected));\n\t\t}\n\t};\n}\n\nexport function numberLessThan(value: number): IConstraint<number> {\n\tconst expected = `expected < ${value}`;\n\treturn numberComparator(lessThan, 's.number.lessThan', expected, value);\n}\n\nexport function numberLessThanOrEqual(value: number): IConstraint<number> {\n\tconst expected = `expected <= ${value}`;\n\treturn numberComparator(lessThanOrEqual, 's.number.lessThanOrEqual', expected, value);\n}\n\nexport function numberGreaterThan(value: number): IConstraint<number> {\n\tconst expected = `expected > ${value}`;\n\treturn numberComparator(greaterThan, 's.number.greaterThan', expected, value);\n}\n\nexport function numberGreaterThanOrEqual(value: number): IConstraint<number> {\n\tconst expected = `expected >= ${value}`;\n\treturn numberComparator(greaterThanOrEqual, 's.number.greaterThanOrEqual', expected, value);\n}\n\nexport function numberEqual(value: number): IConstraint<number> {\n\tconst expected = `expected === ${value}`;\n\treturn numberComparator(equal, 's.number.equal', expected, value);\n}\n\nexport function numberNotEqual(value: number): IConstraint<number> {\n\tconst expected = `expected !== ${value}`;\n\treturn numberComparator(notEqual, 's.number.notEqual', expected, value);\n}\n\nexport const numberInt: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isInteger(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(\n\t\t\t\t\tnew ExpectedConstraintError('s.number.int', 'Given value is not an integer', input, 'Number.isInteger(expected) to be true')\n\t\t\t );\n\t}\n};\n\nexport const numberSafeInt: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isSafeInteger(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(\n\t\t\t\t\tnew ExpectedConstraintError(\n\t\t\t\t\t\t's.number.safeInt',\n\t\t\t\t\t\t'Given value is not a safe integer',\n\t\t\t\t\t\tinput,\n\t\t\t\t\t\t'Number.isSafeInteger(expected) to be true'\n\t\t\t\t\t)\n\t\t\t );\n\t}\n};\n\nexport const numberFinite: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isFinite(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.number.finite', 'Given value is not finite', input, 'Number.isFinite(expected) to be true'));\n\t}\n};\n\nexport const numberNaN: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isNaN(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.number.equal(NaN)', 'Invalid number value', input, 'expected === NaN'));\n\t}\n};\n\nexport const numberNotNaN: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isNaN(input) //\n\t\t\t? Result.err(new ExpectedConstraintError('s.number.notEqual(NaN)', 'Invalid number value', input, 'expected !== NaN'))\n\t\t\t: Result.ok(input);\n\t}\n};\n\nexport function numberDivisibleBy(divider: number): IConstraint<number> {\n\tconst expected = `expected % ${divider} === 0`;\n\treturn {\n\t\trun(input: number) {\n\t\t\treturn input % divider === 0 //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.number.divisibleBy', 'Number is not divisible', input, expected));\n\t\t}\n\t};\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\tnumberDivisibleBy,\n\tnumberEqual,\n\tnumberFinite,\n\tnumberGreaterThan,\n\tnumberGreaterThanOrEqual,\n\tnumberInt,\n\tnumberLessThan,\n\tnumberLessThanOrEqual,\n\tnumberNaN,\n\tnumberNotEqual,\n\tnumberNotNaN,\n\tnumberSafeInt\n} from '../constraints/NumberConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NumberValidator<T extends number> extends BaseValidator<T> {\n\tpublic lessThan(number: number): this {\n\t\treturn this.addConstraint(numberLessThan(number) as IConstraint<T>);\n\t}\n\n\tpublic lessThanOrEqual(number: number): this {\n\t\treturn this.addConstraint(numberLessThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThan(number: number): this {\n\t\treturn this.addConstraint(numberGreaterThan(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThanOrEqual(number: number): this {\n\t\treturn this.addConstraint(numberGreaterThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic equal<N extends number>(number: N): NumberValidator<N> {\n\t\treturn Number.isNaN(number) //\n\t\t\t? (this.addConstraint(numberNaN as IConstraint<T>) as unknown as NumberValidator<N>)\n\t\t\t: (this.addConstraint(numberEqual(number) as IConstraint<T>) as unknown as NumberValidator<N>);\n\t}\n\n\tpublic notEqual(number: number): this {\n\t\treturn Number.isNaN(number) //\n\t\t\t? this.addConstraint(numberNotNaN as IConstraint<T>)\n\t\t\t: this.addConstraint(numberNotEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic get int(): this {\n\t\treturn this.addConstraint(numberInt as IConstraint<T>);\n\t}\n\n\tpublic get safeInt(): this {\n\t\treturn this.addConstraint(numberSafeInt as IConstraint<T>);\n\t}\n\n\tpublic get finite(): this {\n\t\treturn this.addConstraint(numberFinite as IConstraint<T>);\n\t}\n\n\tpublic get positive(): this {\n\t\treturn this.greaterThanOrEqual(0);\n\t}\n\n\tpublic get negative(): this {\n\t\treturn this.lessThan(0);\n\t}\n\n\tpublic divisibleBy(divider: number): this {\n\t\treturn this.addConstraint(numberDivisibleBy(divider) as IConstraint<T>);\n\t}\n\n\tpublic get abs(): this {\n\t\treturn this.transform(Math.abs as (value: number) => T);\n\t}\n\n\tpublic get sign(): this {\n\t\treturn this.transform(Math.sign as (value: number) => T);\n\t}\n\n\tpublic get trunc(): this {\n\t\treturn this.transform(Math.trunc as (value: number) => T);\n\t}\n\n\tpublic get floor(): this {\n\t\treturn this.transform(Math.floor as (value: number) => T);\n\t}\n\n\tpublic get fround(): this {\n\t\treturn this.transform(Math.fround as (value: number) => T);\n\t}\n\n\tpublic get round(): this {\n\t\treturn this.transform(Math.round as (value: number) => T);\n\t}\n\n\tpublic get ceil(): this {\n\t\treturn this.transform(Math.ceil as (value: number) => T);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'number' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.number', 'Expected a number primitive', value));\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class MissingPropertyError extends BaseError {\n\tpublic readonly property: PropertyKey;\n\n\tpublic constructor(property: PropertyKey) {\n\t\tsuper('A required property is missing');\n\t\tthis.property = property;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tproperty: this.property\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst property = options.stylize(this.property.toString(), 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[MissingPropertyError: ${property}]`, 'special');\n\t\t}\n\n\t\tconst header = `${options.stylize('MissingPropertyError', 'special')} > ${property}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\treturn `${header}\\n ${message}`;\n\t}\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class UnknownPropertyError extends BaseError {\n\tpublic readonly property: PropertyKey;\n\tpublic readonly value: unknown;\n\n\tpublic constructor(property: PropertyKey, value: unknown) {\n\t\tsuper('Received unexpected property');\n\n\t\tthis.property = property;\n\t\tthis.value = value;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tproperty: this.property,\n\t\t\tvalue: this.value\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst property = options.stylize(this.property.toString(), 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[UnknownPropertyError: ${property}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst given = inspect(this.value, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('UnknownPropertyError', 'special')} > ${property}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${givenBlock}`;\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { Result } from '../lib/Result';\nimport type { ValidatorError } from './BaseValidator';\nimport { BaseValidator } from './imports';\nimport { getValue } from './util/getValue';\n\nexport class DefaultValidator<T> extends BaseValidator<T> {\n\tprivate readonly validator: BaseValidator<T>;\n\tprivate defaultValue: T | (() => T);\n\n\tpublic constructor(validator: BaseValidator<T>, value: T | (() => T), constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t\tthis.defaultValue = value;\n\t}\n\n\tpublic override default(value: Exclude<T, undefined> | (() => Exclude<T, undefined>)): DefaultValidator<Exclude<T, undefined>> {\n\t\tconst clone = this.clone() as unknown as DefaultValidator<Exclude<T, undefined>>;\n\t\tclone.defaultValue = value;\n\t\treturn clone;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidatorError> {\n\t\treturn typeof value === 'undefined' //\n\t\t\t? Result.ok(getValue(this.defaultValue))\n\t\t\t: this.validator['handle'](value); // eslint-disable-line @typescript-eslint/dot-notation\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.defaultValue, this.constraints]);\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class CombinedError extends BaseError {\n\tpublic readonly errors: readonly BaseError[];\n\n\tpublic constructor(errors: readonly BaseError[]) {\n\t\tsuper('Received one or more errors');\n\n\t\tthis.errors = errors;\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize('[CombinedError]', 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\n\t\tconst header = `${options.stylize('CombinedError', 'special')} (${options.stylize(this.errors.length.toString(), 'number')})`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst errors = this.errors\n\t\t\t.map((error, i) => {\n\t\t\t\tconst index = options.stylize((i + 1).toString(), 'number');\n\t\t\t\tconst body = error[customInspectSymbolStackLess](depth - 1, newOptions).replace(/\\n/g, padding);\n\n\t\t\t\treturn ` ${index} ${body}`;\n\t\t\t})\n\t\t\t.join('\\n\\n');\n\t\treturn `${header}\\n ${message}\\n\\n${errors}`;\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedError } from '../lib/errors/CombinedError';\nimport type { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator, LiteralValidator, NullishValidator } from './imports';\n\nexport class UnionValidator<T> extends BaseValidator<T> {\n\tprivate validators: readonly BaseValidator<T>[];\n\n\tpublic constructor(validators: readonly BaseValidator<T>[], constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validators = validators;\n\t}\n\n\tpublic override get optional(): UnionValidator<T | undefined> {\n\t\tif (this.validators.length === 0) return new UnionValidator<T | undefined>([new LiteralValidator(undefined)], this.constraints);\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\t// If already optional, return a clone:\n\t\t\tif (validator.expected === undefined) return this.clone();\n\n\t\t\t// If it's nullable, convert the nullable validator into a nullish validator to optimize `null | undefined`:\n\t\t\tif (validator.expected === null) {\n\t\t\t\treturn new UnionValidator<T | null | undefined>(\n\t\t\t\t\t[new NullishValidator(), ...this.validators.slice(1)],\n\t\t\t\t\tthis.constraints\n\t\t\t\t) as UnionValidator<T | undefined>;\n\t\t\t}\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t// If it's already nullish (which validates optional), return a clone:\n\t\t\treturn this.clone();\n\t\t}\n\n\t\treturn new UnionValidator([new LiteralValidator(undefined), ...this.validators]);\n\t}\n\n\tpublic get required(): UnionValidator<Exclude<T, undefined>> {\n\t\ttype RequiredValidator = UnionValidator<Exclude<T, undefined>>;\n\n\t\tif (this.validators.length === 0) return this.clone() as unknown as RequiredValidator;\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\tif (validator.expected === undefined) return new UnionValidator(this.validators.slice(1), this.constraints) as RequiredValidator;\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\treturn new UnionValidator([new LiteralValidator(null), ...this.validators.slice(1)], this.constraints) as RequiredValidator;\n\t\t}\n\n\t\treturn this.clone() as unknown as RequiredValidator;\n\t}\n\n\tpublic override get nullable(): UnionValidator<T | null> {\n\t\tif (this.validators.length === 0) return new UnionValidator<T | null>([new LiteralValidator(null)], this.constraints);\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\t// If already nullable, return a clone:\n\t\t\tif (validator.expected === null) return this.clone();\n\n\t\t\t// If it's optional, convert the optional validator into a nullish validator to optimize `null | undefined`:\n\t\t\tif (validator.expected === undefined) {\n\t\t\t\treturn new UnionValidator<T | null | undefined>(\n\t\t\t\t\t[new NullishValidator(), ...this.validators.slice(1)],\n\t\t\t\t\tthis.constraints\n\t\t\t\t) as UnionValidator<T | null>;\n\t\t\t}\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t// If it's already nullish (which validates nullable), return a clone:\n\t\t\treturn this.clone();\n\t\t}\n\n\t\treturn new UnionValidator([new LiteralValidator(null), ...this.validators]);\n\t}\n\n\tpublic override get nullish(): UnionValidator<T | null | undefined> {\n\t\tif (this.validators.length === 0) return new UnionValidator<T | null | undefined>([new NullishValidator()], this.constraints);\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\t// If already nullable or optional, promote the union to nullish:\n\t\t\tif (validator.expected === null || validator.expected === undefined) {\n\t\t\t\treturn new UnionValidator<T | null | undefined>([new NullishValidator(), ...this.validators.slice(1)], this.constraints);\n\t\t\t}\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t// If it's already nullish, return a clone:\n\t\t\treturn this.clone();\n\t\t}\n\n\t\treturn new UnionValidator<T | null | undefined>([new NullishValidator(), ...this.validators]);\n\t}\n\n\tpublic override or<O>(...predicates: readonly BaseValidator<O>[]): UnionValidator<T | O> {\n\t\treturn new UnionValidator<T | O>([...this.validators, ...predicates]);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validators, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError | CombinedError> {\n\t\tconst errors: BaseError[] = [];\n\n\t\tfor (const validator of this.validators) {\n\t\t\tconst result = validator.run(value);\n\t\t\tif (result.isOk()) return result as Result<T, CombinedError>;\n\t\t\terrors.push(result.error!);\n\t\t}\n\n\t\treturn Result.err(new CombinedError(errors));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { MissingPropertyError } from '../lib/errors/MissingPropertyError';\nimport { UnknownPropertyError } from '../lib/errors/UnknownPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport type { MappedObjectValidator, UndefinedToOptional } from '../lib/util-types';\nimport { BaseValidator } from './BaseValidator';\nimport { DefaultValidator } from './DefaultValidator';\nimport { LiteralValidator } from './LiteralValidator';\nimport { NullishValidator } from './NullishValidator';\nimport { UnionValidator } from './UnionValidator';\n\nexport class ObjectValidator<T extends object, I = UndefinedToOptional<T>> extends BaseValidator<I> {\n\tpublic readonly shape: MappedObjectValidator<T>;\n\tpublic readonly strategy: ObjectValidatorStrategy;\n\tprivate readonly keys: readonly (keyof I)[] = [];\n\tprivate readonly handleStrategy: (value: object) => Result<I, CombinedPropertyError>;\n\n\tprivate readonly requiredKeys = new Map<keyof I, BaseValidator<unknown>>();\n\tprivate readonly possiblyUndefinedKeys = new Map<keyof I, BaseValidator<unknown>>();\n\tprivate readonly possiblyUndefinedKeysWithDefaults = new Map<keyof I, DefaultValidator<unknown>>();\n\n\tpublic constructor(\n\t\tshape: MappedObjectValidator<T>,\n\t\tstrategy: ObjectValidatorStrategy = ObjectValidatorStrategy.Ignore,\n\t\tconstraints: readonly IConstraint<I>[] = []\n\t) {\n\t\tsuper(constraints);\n\t\tthis.shape = shape;\n\t\tthis.strategy = strategy;\n\n\t\tswitch (this.strategy) {\n\t\t\tcase ObjectValidatorStrategy.Ignore:\n\t\t\t\tthis.handleStrategy = (value) => this.handleIgnoreStrategy(value);\n\t\t\t\tbreak;\n\t\t\tcase ObjectValidatorStrategy.Strict: {\n\t\t\t\tthis.handleStrategy = (value) => this.handleStrictStrategy(value);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase ObjectValidatorStrategy.Passthrough:\n\t\t\t\tthis.handleStrategy = (value) => this.handlePassthroughStrategy(value);\n\t\t\t\tbreak;\n\t\t}\n\n\t\tconst shapeEntries = Object.entries(shape) as [keyof I, BaseValidator<T>][];\n\t\tthis.keys = shapeEntries.map(([key]) => key);\n\n\t\tfor (const [key, validator] of shapeEntries) {\n\t\t\tif (validator instanceof UnionValidator) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/dot-notation\n\t\t\t\tconst [possiblyLiteralOrNullishPredicate] = validator['validators'];\n\n\t\t\t\tif (possiblyLiteralOrNullishPredicate instanceof NullishValidator) {\n\t\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t\t} else if (possiblyLiteralOrNullishPredicate instanceof LiteralValidator) {\n\t\t\t\t\tif (possiblyLiteralOrNullishPredicate.expected === undefined) {\n\t\t\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t\t\t}\n\t\t\t\t} else if (validator instanceof DefaultValidator) {\n\t\t\t\t\tthis.possiblyUndefinedKeysWithDefaults.set(key, validator);\n\t\t\t\t} else {\n\t\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t\t}\n\t\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t} else if (validator instanceof LiteralValidator) {\n\t\t\t\tif (validator.expected === undefined) {\n\t\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t\t} else {\n\t\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t\t}\n\t\t\t} else if (validator instanceof DefaultValidator) {\n\t\t\t\tthis.possiblyUndefinedKeysWithDefaults.set(key, validator);\n\t\t\t} else {\n\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic get strict(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, ObjectValidatorStrategy.Strict, this.constraints]);\n\t}\n\n\tpublic get ignore(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, ObjectValidatorStrategy.Ignore, this.constraints]);\n\t}\n\n\tpublic get passthrough(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, ObjectValidatorStrategy.Passthrough, this.constraints]);\n\t}\n\n\tpublic get partial(): ObjectValidator<{ [Key in keyof I]?: I[Key] }> {\n\t\tconst shape = Object.fromEntries(this.keys.map((key) => [key, this.shape[key as unknown as keyof typeof this.shape].optional]));\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic get required(): ObjectValidator<{ [Key in keyof I]-?: I[Key] }> {\n\t\tconst shape = Object.fromEntries(\n\t\t\tthis.keys.map((key) => {\n\t\t\t\tlet validator = this.shape[key as unknown as keyof typeof this.shape];\n\t\t\t\tif (validator instanceof UnionValidator) validator = validator.required;\n\t\t\t\treturn [key, validator];\n\t\t\t})\n\t\t);\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic extend<ET extends object>(schema: ObjectValidator<ET> | MappedObjectValidator<ET>): ObjectValidator<T & ET> {\n\t\tconst shape = { ...this.shape, ...(schema instanceof ObjectValidator ? schema.shape : schema) };\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic pick<K extends keyof I>(keys: readonly K[]): ObjectValidator<{ [Key in keyof Pick<I, K>]: I[Key] }> {\n\t\tconst shape = Object.fromEntries(\n\t\t\tkeys.filter((key) => this.keys.includes(key)).map((key) => [key, this.shape[key as unknown as keyof typeof this.shape]])\n\t\t);\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic omit<K extends keyof I>(keys: readonly K[]): ObjectValidator<{ [Key in keyof Omit<I, K>]: I[Key] }> {\n\t\tconst shape = Object.fromEntries(\n\t\t\tthis.keys.filter((key) => !keys.includes(key as any)).map((key) => [key, this.shape[key as unknown as keyof typeof this.shape]])\n\t\t);\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tprotected override handle(value: unknown): Result<I, ValidationError | CombinedPropertyError> {\n\t\tconst typeOfValue = typeof value;\n\t\tif (typeOfValue !== 'object') {\n\t\t\treturn Result.err(new ValidationError('s.object(T)', `Expected the value to be an object, but received ${typeOfValue} instead`, value));\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn Result.err(new ValidationError('s.object(T)', 'Expected the value to not be null', value));\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\treturn Result.err(new ValidationError('s.object(T)', 'Expected the value to not be an array', value));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(value as I);\n\t\t}\n\n\t\tfor (const predicate of Object.values(this.shape) as BaseValidator<any>[]) {\n\t\t\tpredicate.setParent(this.parent ?? value!);\n\t\t}\n\n\t\treturn this.handleStrategy(value as object);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, this.strategy, this.constraints]);\n\t}\n\n\tprivate handleIgnoreStrategy(value: object): Result<I, CombinedPropertyError> {\n\t\tconst errors: [PropertyKey, BaseError][] = [];\n\t\tconst finalObject = {} as I;\n\t\tconst inputEntries = new Map(Object.entries(value) as [keyof I, unknown][]);\n\n\t\tconst runPredicate = (key: keyof I, predicate: BaseValidator<unknown>) => {\n\t\t\tconst result = predicate.run(value[key as keyof object]);\n\n\t\t\tif (result.isOk()) {\n\t\t\t\tfinalObject[key] = result.value as I[keyof I];\n\t\t\t} else {\n\t\t\t\tconst error = result.error!;\n\t\t\t\terrors.push([key, error]);\n\t\t\t}\n\t\t};\n\n\t\tfor (const [key, predicate] of this.requiredKeys) {\n\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\trunPredicate(key, predicate);\n\t\t\t} else {\n\t\t\t\terrors.push([key, new MissingPropertyError(key)]);\n\t\t\t}\n\t\t}\n\n\t\t// Run possibly undefined keys that also have defaults even if there are no more keys to process (this is necessary so we fill in those defaults)\n\t\tfor (const [key, validator] of this.possiblyUndefinedKeysWithDefaults) {\n\t\t\tinputEntries.delete(key);\n\t\t\trunPredicate(key, validator);\n\t\t}\n\n\t\t// Early exit if there are no more properties to validate in the object and there are errors to report\n\t\tif (inputEntries.size === 0) {\n\t\t\treturn errors.length === 0 //\n\t\t\t\t? Result.ok(finalObject)\n\t\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t\t}\n\n\t\t// In the event the remaining keys to check are less than the number of possible undefined keys, we check those\n\t\t// as it could yield a faster execution\n\t\tconst checkInputEntriesInsteadOfSchemaKeys = this.possiblyUndefinedKeys.size > inputEntries.size;\n\n\t\tif (checkInputEntriesInsteadOfSchemaKeys) {\n\t\t\tfor (const [key] of inputEntries) {\n\t\t\t\tconst predicate = this.possiblyUndefinedKeys.get(key);\n\n\t\t\t\tif (predicate) {\n\t\t\t\t\trunPredicate(key, predicate);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor (const [key, predicate] of this.possiblyUndefinedKeys) {\n\t\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\t\trunPredicate(key, predicate);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(finalObject)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n\n\tprivate handleStrictStrategy(value: object): Result<I, CombinedPropertyError> {\n\t\tconst errors: [PropertyKey, BaseError][] = [];\n\t\tconst finalResult = {} as I;\n\t\tconst inputEntries = new Map(Object.entries(value) as [keyof I, unknown][]);\n\n\t\tconst runPredicate = (key: keyof I, predicate: BaseValidator<unknown>) => {\n\t\t\tconst result = predicate.run(value[key as keyof object]);\n\n\t\t\tif (result.isOk()) {\n\t\t\t\tfinalResult[key] = result.value as I[keyof I];\n\t\t\t} else {\n\t\t\t\tconst error = result.error!;\n\t\t\t\terrors.push([key, error]);\n\t\t\t}\n\t\t};\n\n\t\tfor (const [key, predicate] of this.requiredKeys) {\n\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\trunPredicate(key, predicate);\n\t\t\t} else {\n\t\t\t\terrors.push([key, new MissingPropertyError(key)]);\n\t\t\t}\n\t\t}\n\n\t\t// Run possibly undefined keys that also have defaults even if there are no more keys to process (this is necessary so we fill in those defaults)\n\t\tfor (const [key, validator] of this.possiblyUndefinedKeysWithDefaults) {\n\t\t\tinputEntries.delete(key);\n\t\t\trunPredicate(key, validator);\n\t\t}\n\n\t\tfor (const [key, predicate] of this.possiblyUndefinedKeys) {\n\t\t\t// All of these validators are assumed to be possibly undefined, so if we have gone through the entire object and there's still validators,\n\t\t\t// safe to assume we're done here\n\t\t\tif (inputEntries.size === 0) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\trunPredicate(key, predicate);\n\t\t\t}\n\t\t}\n\n\t\tif (inputEntries.size !== 0) {\n\t\t\tfor (const [key, value] of inputEntries.entries()) {\n\t\t\t\terrors.push([key, new UnknownPropertyError(key, value)]);\n\t\t\t}\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(finalResult)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n\n\tprivate handlePassthroughStrategy(value: object): Result<I, CombinedPropertyError> {\n\t\tconst result = this.handleIgnoreStrategy(value);\n\t\treturn result.isErr() ? result : Result.ok({ ...value, ...result.value } as I);\n\t}\n}\n\nexport enum ObjectValidatorStrategy {\n\tIgnore,\n\tStrict,\n\tPassthrough\n}\n","import type { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class PassthroughValidator<T extends any | unknown> extends BaseValidator<T> {\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn Result.ok(value as T);\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class RecordValidator<T> extends BaseValidator<Record<string, T>> {\n\tprivate readonly validator: BaseValidator<T>;\n\n\tpublic constructor(validator: BaseValidator<T>, constraints: readonly IConstraint<Record<string, T>>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<Record<string, T>, ValidationError | CombinedPropertyError> {\n\t\tif (typeof value !== 'object') {\n\t\t\treturn Result.err(new ValidationError('s.record(T)', 'Expected an object', value));\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn Result.err(new ValidationError('s.record(T)', 'Expected the value to not be null', value));\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\treturn Result.err(new ValidationError('s.record(T)', 'Expected the value to not be an array', value));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(value as Record<string, T>);\n\t\t}\n\n\t\tconst errors: [string, BaseError][] = [];\n\t\tconst transformed: Record<string, T> = {};\n\n\t\tfor (const [key, val] of Object.entries(value!)) {\n\t\t\tconst result = this.validator.run(val);\n\t\t\tif (result.isOk()) transformed[key] = result.value;\n\t\t\telse errors.push([key, result.error!]);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedError } from '../lib/errors/CombinedError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class SetValidator<T> extends BaseValidator<Set<T>> {\n\tprivate readonly validator: BaseValidator<T>;\n\n\tpublic constructor(validator: BaseValidator<T>, constraints: readonly IConstraint<Set<T>>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<Set<T>, ValidationError | CombinedError> {\n\t\tif (!(values instanceof Set)) {\n\t\t\treturn Result.err(new ValidationError('s.set(T)', 'Expected a set', values));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(values);\n\t\t}\n\n\t\tconst errors: BaseError[] = [];\n\t\tconst transformed = new Set<T>();\n\n\t\tfor (const value of values) {\n\t\t\tconst result = this.validator.run(value);\n\t\t\tif (result.isOk()) transformed.add(result.value);\n\t\t\telse errors.push(result.error!);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedError(errors));\n\t}\n}\n","/**\n * [RFC-5322](https://datatracker.ietf.org/doc/html/rfc5322)\n * compliant {@link RegExp} to validate an email address\n *\n * @see https://stackoverflow.com/questions/201323/how-can-i-validate-an-email-address-using-a-regular-expression/201378#201378\n */\nconst accountRegex =\n\t/^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")$/;\n\n/**\n * Validates an email address string based on various checks:\n * - It must be a non nullish and non empty string\n * - It must include at least an `@` symbol`\n * - The account name may not exceed 64 characters\n * - The domain name may not exceed 255 characters\n * - The domain must include at least one `.` symbol\n * - Each part of the domain, split by `.` must not exceed 63 characters\n * - The email address must be [RFC-5322](https://datatracker.ietf.org/doc/html/rfc5322) compliant\n * @param email The email to validate\n * @returns `true` if the email is valid, `false` otherwise\n *\n * @remark Based on the following sources:\n * - `email-validator` by [manisharaan](https://github.com/manishsaraan) ([code](https://github.com/manishsaraan/email-validator/blob/master/index.js))\n * - [Comparing E-mail Address Validating Regular Expressions](http://fightingforalostcause.net/misc/2006/compare-email-regex.php)\n * - [Validating Email Addresses by Derrick Pallas](http://thedailywtf.com/Articles/Validating_Email_Addresses.aspx)\n * - [StackOverflow answer by bortzmeyer](http://stackoverflow.com/questions/201323/what-is-the-best-regular-expression-for-validating-email-addresses/201378#201378)\n * - [The wikipedia page on Email addresses](https://en.wikipedia.org/wiki/Email_address)\n */\nexport function validateEmail(email: string): boolean {\n\t// 1. Non-nullish and non-empty string check.\n\t//\n\t// If a nullish or empty email was provided then do an early exit\n\tif (!email) return false;\n\n\t// Find the location of the @ symbol:\n\tconst atIndex = email.indexOf('@');\n\n\t// 2. @ presence check.\n\t//\n\t// If the email does not have the @ symbol, it's automatically invalid:\n\tif (atIndex === -1) return false;\n\n\t// 3. <account> maximum length check.\n\t//\n\t// From <account>@<domain>, if <account> exceeds 64 characters, then the\n\t// position of the @ symbol is 64 or greater. In this case, the email is\n\t// invalid:\n\tif (atIndex > 64) return false;\n\n\tconst domainIndex = atIndex + 1;\n\n\t// 7.1. Duplicated @ symbol check.\n\t//\n\t// If there's a second @ symbol, the email is automatically invalid:\n\tif (email.includes('@', domainIndex)) return false;\n\n\t// 4. <domain> maximum length check.\n\t//\n\t// From <account>@<domain>, if <domain> exceeds 255 characters, then it\n\t// means that the amount of characters between the start of <domain> and the\n\t// end of the string is separated by 255 or more characters.\n\tif (email.length - domainIndex > 255) return false;\n\n\t// Find the location of the . symbol in <domain>:\n\tlet dotIndex = email.indexOf('.', domainIndex);\n\n\t// 5. <domain> dot (.) symbol check.\n\t//\n\t// From <account>@<domain>, if <domain> does not contain a dot (.) symbol,\n\t// then it means the domain is invalid.\n\tif (dotIndex === -1) return false;\n\n\t// 6. <domain> parts length.\n\t//\n\t// Assign a temporary variable to store the start of the last read domain\n\t// part, this would be at the start of <domain>.\n\t//\n\t// For a <domain> part to be correct, it must have at most, 63 characters.\n\t// We repeat this step for every sub-section of <domain> contained within\n\t// dot (.) symbols.\n\t//\n\t// The following step is a more optimized version of the following code:\n\t//\n\t// ```javascript\n\t// domain.split('.').some((part) => part.length > 63);\n\t// ```\n\tlet lastDotIndex = domainIndex;\n\tdo {\n\t\tif (dotIndex - lastDotIndex > 63) return false;\n\n\t\tlastDotIndex = dotIndex + 1;\n\t} while ((dotIndex = email.indexOf('.', lastDotIndex)) !== -1);\n\n\t// The loop iterates from the first to the n - 1 part, this line checks for\n\t// the last (n) part:\n\tif (email.length - lastDotIndex > 63) return false;\n\n\t// 7.2. Character checks.\n\t//\n\t// From <account>@<domain>:\n\t// - Extract the <account> part by slicing the input from start to the @\n\t// character. Validate afterwards.\n\t// - Extract the <domain> part by slicing the input from the start of\n\t// <domain>. Validate afterwards.\n\t//\n\t// Note: we inline the variables so <domain> isn't created unless the\n\t// <account> check passes.\n\treturn accountRegex.test(email.slice(0, atIndex)) && validateEmailDomain(email.slice(domainIndex));\n}\n\nfunction validateEmailDomain(domain: string): boolean {\n\ttry {\n\t\treturn new URL(`http://${domain}`).hostname === domain;\n\t} catch {\n\t\treturn false;\n\t}\n}\n","/**\n * Code ported from https://github.com/nodejs/node/blob/5fad0b93667ffc6e4def52996b9529ac99b26319/lib/internal/net.js\n */\n\n// IPv4 Segment\nconst v4Seg = '(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])';\nconst v4Str = `(${v4Seg}[.]){3}${v4Seg}`;\nconst IPv4Reg = new RegExp(`^${v4Str}$`);\n\n// IPv6 Segment\nconst v6Seg = '(?:[0-9a-fA-F]{1,4})';\nconst IPv6Reg = new RegExp(\n\t'^(' +\n\t\t`(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +\n\t\t`(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +\n\t\t`(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` +\n\t\t`(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` +\n\t\t`(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` +\n\t\t`(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` +\n\t\t`(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` +\n\t\t`(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +\n\t\t')(%[0-9a-zA-Z-.:]{1,})?$'\n);\n\nexport function isIPv4(s: string): boolean {\n\treturn IPv4Reg.test(s);\n}\n\nexport function isIPv6(s: string): boolean {\n\treturn IPv6Reg.test(s);\n}\n\nexport function isIP(s: string): number {\n\tif (isIPv4(s)) return 4;\n\tif (isIPv6(s)) return 6;\n\treturn 0;\n}\n","export const phoneNumberRegex = /^((?:\\+|0{0,2})\\d{1,2}\\s?)?\\(?\\d{3}\\)?[\\s.-]?\\d{3}[\\s.-]?\\d{4}$/;\n\nexport function validatePhoneNumber(input: string) {\n\treturn phoneNumberRegex.test(input);\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { customInspectSymbolStackLess } from './BaseError';\nimport { BaseConstraintError, type ConstraintErrorNames } from './BaseConstraintError';\n\nexport class MultiplePossibilitiesConstraintError<T = unknown> extends BaseConstraintError<T> {\n\tpublic readonly expected: readonly string[];\n\n\tpublic constructor(constraint: ConstraintErrorNames, message: string, given: T, expected: readonly string[]) {\n\t\tsuper(constraint, message, given);\n\t\tthis.expected = expected;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tconstraint: this.constraint,\n\t\t\tgiven: this.given,\n\t\t\texpected: this.expected\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst constraint = options.stylize(this.constraint, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[MultiplePossibilitiesConstraintError: ${constraint}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1 };\n\n\t\tconst verticalLine = options.stylize('|', 'undefined');\n\t\tconst padding = `\\n ${verticalLine} `;\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('MultiplePossibilitiesConstraintError', 'special')} > ${constraint}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\n\t\tconst expectedPadding = `\\n ${verticalLine} - `;\n\t\tconst expectedBlock = `\\n ${options.stylize('Expected any of the following:', 'string')}${expectedPadding}${this.expected\n\t\t\t.map((possible) => options.stylize(possible, 'boolean'))\n\t\t\t.join(expectedPadding)}`;\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${expectedBlock}\\n${givenBlock}`;\n\t}\n}\n","export function combinedErrorFn<P extends [...any], E extends Error>(...fns: ErrorFn<P, E>[]): ErrorFn<P, E> {\n\tswitch (fns.length) {\n\t\tcase 0:\n\t\t\treturn () => null;\n\t\tcase 1:\n\t\t\treturn fns[0];\n\t\tcase 2: {\n\t\t\tconst [fn0, fn1] = fns;\n\t\t\treturn (...params) => fn0(...params) || fn1(...params);\n\t\t}\n\t\tdefault: {\n\t\t\treturn (...params) => {\n\t\t\t\tfor (const fn of fns) {\n\t\t\t\t\tconst result = fn(...params);\n\t\t\t\t\tif (result) return result;\n\t\t\t\t}\n\n\t\t\t\treturn null;\n\t\t\t};\n\t\t}\n\t}\n}\n\nexport type ErrorFn<P extends [...any], E extends Error> = (...params: P) => E | null;\n","import { MultiplePossibilitiesConstraintError } from '../../lib/errors/MultiplePossibilitiesConstraintError';\nimport { combinedErrorFn, type ErrorFn } from './common/combinedResultFn';\n\nexport type StringProtocol = `${string}:`;\n\nexport type StringDomain = `${string}.${string}`;\n\nexport interface UrlOptions {\n\tallowedProtocols?: StringProtocol[];\n\tallowedDomains?: StringDomain[];\n}\n\nexport function createUrlValidators(options?: UrlOptions) {\n\tconst fns: ErrorFn<[input: string, url: URL], MultiplePossibilitiesConstraintError<string>>[] = [];\n\n\tif (options?.allowedProtocols?.length) fns.push(allowedProtocolsFn(options.allowedProtocols));\n\tif (options?.allowedDomains?.length) fns.push(allowedDomainsFn(options.allowedDomains));\n\n\treturn combinedErrorFn(...fns);\n}\n\nfunction allowedProtocolsFn(allowedProtocols: StringProtocol[]) {\n\treturn (input: string, url: URL) =>\n\t\tallowedProtocols.includes(url.protocol as StringProtocol)\n\t\t\t? null\n\t\t\t: new MultiplePossibilitiesConstraintError('s.string.url', 'Invalid URL protocol', input, allowedProtocols);\n}\n\nfunction allowedDomainsFn(allowedDomains: StringDomain[]) {\n\treturn (input: string, url: URL) =>\n\t\tallowedDomains.includes(url.hostname as StringDomain)\n\t\t\t? null\n\t\t\t: new MultiplePossibilitiesConstraintError('s.string.url', 'Invalid URL domain', input, allowedDomains);\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { validateEmail } from './util/emailValidator';\nimport { isIP, isIPv4, isIPv6 } from './util/net';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\nimport { validatePhoneNumber } from './util/phoneValidator';\nimport { createUrlValidators } from './util/urlValidators';\n\nexport type StringConstraintName =\n\t| `s.string.${\n\t\t\t| `length${'LessThan' | 'LessThanOrEqual' | 'GreaterThan' | 'GreaterThanOrEqual' | 'Equal' | 'NotEqual'}`\n\t\t\t| 'regex'\n\t\t\t| 'url'\n\t\t\t| 'uuid'\n\t\t\t| 'email'\n\t\t\t| `ip${'v4' | 'v6' | ''}`\n\t\t\t| 'date'\n\t\t\t| 'phone'}`;\n\nexport type StringProtocol = `${string}:`;\n\nexport type StringDomain = `${string}.${string}`;\n\nexport interface UrlOptions {\n\tallowedProtocols?: StringProtocol[];\n\tallowedDomains?: StringDomain[];\n}\n\nexport type UUIDVersion = 1 | 3 | 4 | 5;\n\nexport interface StringUuidOptions {\n\tversion?: UUIDVersion | `${UUIDVersion}-${UUIDVersion}` | null;\n\tnullable?: boolean;\n}\n\nfunction stringLengthComparator(comparator: Comparator, name: StringConstraintName, expected: string, length: number): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn comparator(input.length, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid string length', input, expected));\n\t\t}\n\t};\n}\n\nexport function stringLengthLessThan(length: number): IConstraint<string> {\n\tconst expected = `expected.length < ${length}`;\n\treturn stringLengthComparator(lessThan, 's.string.lengthLessThan', expected, length);\n}\n\nexport function stringLengthLessThanOrEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length <= ${length}`;\n\treturn stringLengthComparator(lessThanOrEqual, 's.string.lengthLessThanOrEqual', expected, length);\n}\n\nexport function stringLengthGreaterThan(length: number): IConstraint<string> {\n\tconst expected = `expected.length > ${length}`;\n\treturn stringLengthComparator(greaterThan, 's.string.lengthGreaterThan', expected, length);\n}\n\nexport function stringLengthGreaterThanOrEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length >= ${length}`;\n\treturn stringLengthComparator(greaterThanOrEqual, 's.string.lengthGreaterThanOrEqual', expected, length);\n}\n\nexport function stringLengthEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length === ${length}`;\n\treturn stringLengthComparator(equal, 's.string.lengthEqual', expected, length);\n}\n\nexport function stringLengthNotEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length !== ${length}`;\n\treturn stringLengthComparator(notEqual, 's.string.lengthNotEqual', expected, length);\n}\n\nexport function stringEmail(): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn validateEmail(input)\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.string.email', 'Invalid email address', input, 'expected to be an email address'));\n\t\t}\n\t};\n}\n\nfunction stringRegexValidator(type: StringConstraintName, expected: string, regex: RegExp): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn regex.test(input) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(type, 'Invalid string format', input, expected));\n\t\t}\n\t};\n}\n\nexport function stringUrl(options?: UrlOptions): IConstraint<string> {\n\tconst validatorFn = createUrlValidators(options);\n\treturn {\n\t\trun(input: string) {\n\t\t\tlet url: URL;\n\t\t\ttry {\n\t\t\t\turl = new URL(input);\n\t\t\t} catch {\n\t\t\t\treturn Result.err(new ExpectedConstraintError('s.string.url', 'Invalid URL', input, 'expected to match a URL'));\n\t\t\t}\n\n\t\t\tconst validatorFnResult = validatorFn(input, url);\n\t\t\tif (validatorFnResult === null) return Result.ok(input);\n\t\t\treturn Result.err(validatorFnResult);\n\t\t}\n\t};\n}\n\nexport function stringIp(version?: 4 | 6): IConstraint<string> {\n\tconst ipVersion = version ? (`v${version}` as const) : '';\n\tconst validatorFn = version === 4 ? isIPv4 : version === 6 ? isIPv6 : isIP;\n\n\tconst name = `s.string.ip${ipVersion}` as const;\n\tconst message = `Invalid IP${ipVersion} address`;\n\tconst expected = `expected to be an IP${ipVersion} address`;\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn validatorFn(input) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, message, input, expected));\n\t\t}\n\t};\n}\n\nexport function stringRegex(regex: RegExp) {\n\treturn stringRegexValidator('s.string.regex', `expected ${regex}.test(expected) to be true`, regex);\n}\n\nexport function stringUuid({ version = 4, nullable = false }: StringUuidOptions = {}) {\n\tversion ??= '1-5';\n\tconst regex = new RegExp(\n\t\t`^(?:[0-9A-F]{8}-[0-9A-F]{4}-[${version}][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}${\n\t\t\tnullable ? '|00000000-0000-0000-0000-000000000000' : ''\n\t\t})$`,\n\t\t'i'\n\t);\n\tconst expected = `expected to match UUID${typeof version === 'number' ? `v${version}` : ` in range of ${version}`}`;\n\treturn stringRegexValidator('s.string.uuid', expected, regex);\n}\n\nexport function stringDate(): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\tconst time = Date.parse(input);\n\n\t\t\treturn Number.isNaN(time)\n\t\t\t\t? Result.err(\n\t\t\t\t\t\tnew ExpectedConstraintError(\n\t\t\t\t\t\t\t's.string.date',\n\t\t\t\t\t\t\t'Invalid date string',\n\t\t\t\t\t\t\tinput,\n\t\t\t\t\t\t\t'expected to be a valid date string (in the ISO 8601 or ECMA-262 format)'\n\t\t\t\t\t\t)\n\t\t\t\t )\n\t\t\t\t: Result.ok(input);\n\t\t}\n\t};\n}\n\nexport function stringPhone(): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn validatePhoneNumber(input)\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.string.phone', 'Invalid phone number', input, 'expected to be a phone number'));\n\t\t}\n\t};\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\tstringDate,\n\tstringEmail,\n\tstringIp,\n\tstringLengthEqual,\n\tstringLengthGreaterThan,\n\tstringLengthGreaterThanOrEqual,\n\tstringLengthLessThan,\n\tstringLengthLessThanOrEqual,\n\tstringLengthNotEqual,\n\tstringPhone,\n\tstringRegex,\n\tstringUrl,\n\tstringUuid,\n\ttype StringUuidOptions,\n\ttype UrlOptions\n} from '../constraints/StringConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class StringValidator<T extends string> extends BaseValidator<T> {\n\tpublic lengthLessThan(length: number): this {\n\t\treturn this.addConstraint(stringLengthLessThan(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthLessThanOrEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthLessThanOrEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthGreaterThan(length: number): this {\n\t\treturn this.addConstraint(stringLengthGreaterThan(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthGreaterThanOrEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthGreaterThanOrEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthNotEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthNotEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic get email(): this {\n\t\treturn this.addConstraint(stringEmail() as IConstraint<T>);\n\t}\n\n\tpublic url(options?: UrlOptions): this {\n\t\treturn this.addConstraint(stringUrl(options) as IConstraint<T>);\n\t}\n\n\tpublic uuid(options?: StringUuidOptions): this {\n\t\treturn this.addConstraint(stringUuid(options) as IConstraint<T>);\n\t}\n\n\tpublic regex(regex: RegExp): this {\n\t\treturn this.addConstraint(stringRegex(regex) as IConstraint<T>);\n\t}\n\n\tpublic get date() {\n\t\treturn this.addConstraint(stringDate() as IConstraint<T>);\n\t}\n\n\tpublic get ipv4(): this {\n\t\treturn this.ip(4);\n\t}\n\n\tpublic get ipv6(): this {\n\t\treturn this.ip(6);\n\t}\n\n\tpublic ip(version?: 4 | 6): this {\n\t\treturn this.addConstraint(stringIp(version) as IConstraint<T>);\n\t}\n\n\tpublic phone(): this {\n\t\treturn this.addConstraint(stringPhone() as IConstraint<T>);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'string' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.string', 'Expected a string primitive', value));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class TupleValidator<T extends any[]> extends BaseValidator<[...T]> {\n\tprivate readonly validators: BaseValidator<[...T]>[] = [];\n\n\tpublic constructor(validators: BaseValidator<[...T]>[], constraints: readonly IConstraint<[...T]>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validators = validators;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validators, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<[...T], ValidationError | CombinedPropertyError> {\n\t\tif (!Array.isArray(values)) {\n\t\t\treturn Result.err(new ValidationError('s.tuple(T)', 'Expected an array', values));\n\t\t}\n\n\t\tif (values.length !== this.validators.length) {\n\t\t\treturn Result.err(new ValidationError('s.tuple(T)', `Expected an array of length ${this.validators.length}`, values));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(values as [...T]);\n\t\t}\n\n\t\tconst errors: [number, BaseError][] = [];\n\t\tconst transformed: T = [] as unknown as T;\n\n\t\tfor (let i = 0; i < values.length; i++) {\n\t\t\tconst result = this.validators[i].run(values[i]);\n\t\t\tif (result.isOk()) transformed.push(result.value);\n\t\t\telse errors.push([i, result.error!]);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class MapValidator<K, V> extends BaseValidator<Map<K, V>> {\n\tprivate readonly keyValidator: BaseValidator<K>;\n\tprivate readonly valueValidator: BaseValidator<V>;\n\n\tpublic constructor(keyValidator: BaseValidator<K>, valueValidator: BaseValidator<V>, constraints: readonly IConstraint<Map<K, V>>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.keyValidator = keyValidator;\n\t\tthis.valueValidator = valueValidator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.keyValidator, this.valueValidator, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<Map<K, V>, ValidationError | CombinedPropertyError> {\n\t\tif (!(value instanceof Map)) {\n\t\t\treturn Result.err(new ValidationError('s.map(K, V)', 'Expected a map', value));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(value);\n\t\t}\n\n\t\tconst errors: [string, BaseError][] = [];\n\t\tconst transformed = new Map<K, V>();\n\n\t\tfor (const [key, val] of value.entries()) {\n\t\t\tconst keyResult = this.keyValidator.run(key);\n\t\t\tconst valueResult = this.valueValidator.run(val);\n\t\t\tconst { length } = errors;\n\t\t\tif (keyResult.isErr()) errors.push([key, keyResult.error]);\n\t\t\tif (valueResult.isErr()) errors.push([key, valueResult.error]);\n\t\t\tif (errors.length === length) transformed.set(keyResult.value!, valueResult.value!);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import type { Result } from '../lib/Result';\nimport type { IConstraint, Unwrap } from '../type-exports';\nimport { BaseValidator, type ValidatorError } from './imports';\n\nexport class LazyValidator<T extends BaseValidator<unknown>, R = Unwrap<T>> extends BaseValidator<R> {\n\tprivate readonly validator: (value: unknown) => T;\n\n\tpublic constructor(validator: (value: unknown) => T, constraints: readonly IConstraint<R>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<R, ValidatorError> {\n\t\treturn this.validator(values).run(values) as Result<R, ValidatorError>;\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class UnknownEnumValueError extends BaseError {\n\tpublic readonly value: string | number;\n\tpublic readonly enumKeys: string[];\n\tpublic readonly enumMappings: Map<string | number, string | number>;\n\n\tpublic constructor(value: string | number, keys: string[], enumMappings: Map<string | number, string | number>) {\n\t\tsuper('Expected the value to be one of the following enum values:');\n\n\t\tthis.value = value;\n\t\tthis.enumKeys = keys;\n\t\tthis.enumMappings = enumMappings;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tvalue: this.value,\n\t\t\tenumKeys: this.enumKeys,\n\t\t\tenumMappings: [...this.enumMappings.entries()]\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst value = options.stylize(this.value.toString(), 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[UnknownEnumValueError: ${value}]`, 'special');\n\t\t}\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst pairs = this.enumKeys\n\t\t\t.map((key) => {\n\t\t\t\tconst enumValue = this.enumMappings.get(key)!;\n\t\t\t\treturn `${options.stylize(key, 'string')} or ${options.stylize(\n\t\t\t\t\tenumValue.toString(),\n\t\t\t\t\ttypeof enumValue === 'number' ? 'number' : 'string'\n\t\t\t\t)}`;\n\t\t\t})\n\t\t\t.join(padding);\n\n\t\tconst header = `${options.stylize('UnknownEnumValueError', 'special')} > ${value}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst pairsBlock = `${padding}${pairs}`;\n\t\treturn `${header}\\n ${message}\\n${pairsBlock}`;\n\t}\n}\n","import { UnknownEnumValueError } from '../lib/errors/UnknownEnumValueError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NativeEnumValidator<T extends NativeEnumLike> extends BaseValidator<T[keyof T]> {\n\tpublic readonly enumShape: T;\n\tpublic readonly hasNumericElements: boolean = false;\n\tprivate readonly enumKeys: string[];\n\tprivate readonly enumMapping = new Map<string | number, T[keyof T]>();\n\n\tpublic constructor(enumShape: T) {\n\t\tsuper();\n\t\tthis.enumShape = enumShape;\n\n\t\tthis.enumKeys = Object.keys(enumShape).filter((key) => {\n\t\t\treturn typeof enumShape[enumShape[key]] !== 'number';\n\t\t});\n\n\t\tfor (const key of this.enumKeys) {\n\t\t\tconst enumValue = enumShape[key] as T[keyof T];\n\n\t\t\tthis.enumMapping.set(key, enumValue);\n\t\t\tthis.enumMapping.set(enumValue, enumValue);\n\n\t\t\tif (typeof enumValue === 'number') {\n\t\t\t\tthis.hasNumericElements = true;\n\t\t\t\tthis.enumMapping.set(`${enumValue}`, enumValue);\n\t\t\t}\n\t\t}\n\t}\n\n\tprotected override handle(value: unknown): Result<T[keyof T], ValidationError | UnknownEnumValueError> {\n\t\tconst typeOfValue = typeof value;\n\n\t\tif (typeOfValue === 'number') {\n\t\t\tif (!this.hasNumericElements) {\n\t\t\t\treturn Result.err(new ValidationError('s.nativeEnum(T)', 'Expected the value to be a string', value));\n\t\t\t}\n\t\t} else if (typeOfValue !== 'string') {\n\t\t\t// typeOfValue !== 'number' is implied here\n\t\t\treturn Result.err(new ValidationError('s.nativeEnum(T)', 'Expected the value to be a string or number', value));\n\t\t}\n\n\t\tconst casted = value as string | number;\n\n\t\tconst possibleEnumValue = this.enumMapping.get(casted);\n\n\t\treturn typeof possibleEnumValue === 'undefined'\n\t\t\t? Result.err(new UnknownEnumValueError(casted, this.enumKeys, this.enumMapping))\n\t\t\t: Result.ok(possibleEnumValue);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.enumShape]);\n\t}\n}\n\nexport interface NativeEnumLike {\n\t[key: string]: string | number;\n\t[key: number]: string;\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\nimport type { TypedArray } from './util/typedArray';\n\nexport type TypedArrayConstraintName = `s.typedArray(T).${'byteLength' | 'length'}${\n\t| 'LessThan'\n\t| 'LessThanOrEqual'\n\t| 'GreaterThan'\n\t| 'GreaterThanOrEqual'\n\t| 'Equal'\n\t| 'NotEqual'\n\t| 'Range'\n\t| 'RangeInclusive'\n\t| 'RangeExclusive'}`;\n\nfunction typedArrayByteLengthComparator<T extends TypedArray>(\n\tcomparator: Comparator,\n\tname: TypedArrayConstraintName,\n\texpected: string,\n\tlength: number\n): IConstraint<T> {\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn comparator(input.byteLength, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Typed Array byte length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayByteLengthLessThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength < ${value}`;\n\treturn typedArrayByteLengthComparator(lessThan, 's.typedArray(T).byteLengthLessThan', expected, value);\n}\n\nexport function typedArrayByteLengthLessThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength <= ${value}`;\n\treturn typedArrayByteLengthComparator(lessThanOrEqual, 's.typedArray(T).byteLengthLessThanOrEqual', expected, value);\n}\n\nexport function typedArrayByteLengthGreaterThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength > ${value}`;\n\treturn typedArrayByteLengthComparator(greaterThan, 's.typedArray(T).byteLengthGreaterThan', expected, value);\n}\n\nexport function typedArrayByteLengthGreaterThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength >= ${value}`;\n\treturn typedArrayByteLengthComparator(greaterThanOrEqual, 's.typedArray(T).byteLengthGreaterThanOrEqual', expected, value);\n}\n\nexport function typedArrayByteLengthEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength === ${value}`;\n\treturn typedArrayByteLengthComparator(equal, 's.typedArray(T).byteLengthEqual', expected, value);\n}\n\nexport function typedArrayByteLengthNotEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength !== ${value}`;\n\treturn typedArrayByteLengthComparator(notEqual, 's.typedArray(T).byteLengthNotEqual', expected, value);\n}\n\nexport function typedArrayByteLengthRange<T extends TypedArray>(start: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.byteLength >= ${start} && expected.byteLength < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.byteLength >= start && input.byteLength < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).byteLengthRange', 'Invalid Typed Array byte length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayByteLengthRangeInclusive<T extends TypedArray>(start: number, end: number) {\n\tconst expected = `expected.byteLength >= ${start} && expected.byteLength <= ${end}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.byteLength >= start && input.byteLength <= end //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(\n\t\t\t\t\t\tnew ExpectedConstraintError('s.typedArray(T).byteLengthRangeInclusive', 'Invalid Typed Array byte length', input, expected)\n\t\t\t\t );\n\t\t}\n\t};\n}\n\nexport function typedArrayByteLengthRangeExclusive<T extends TypedArray>(startAfter: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.byteLength > ${startAfter} && expected.byteLength < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.byteLength > startAfter && input.byteLength < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(\n\t\t\t\t\t\tnew ExpectedConstraintError('s.typedArray(T).byteLengthRangeExclusive', 'Invalid Typed Array byte length', input, expected)\n\t\t\t\t );\n\t\t}\n\t};\n}\n\nfunction typedArrayLengthComparator<T extends TypedArray>(\n\tcomparator: Comparator,\n\tname: TypedArrayConstraintName,\n\texpected: string,\n\tlength: number\n): IConstraint<T> {\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn comparator(input.length, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayLengthLessThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length < ${value}`;\n\treturn typedArrayLengthComparator(lessThan, 's.typedArray(T).lengthLessThan', expected, value);\n}\n\nexport function typedArrayLengthLessThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length <= ${value}`;\n\treturn typedArrayLengthComparator(lessThanOrEqual, 's.typedArray(T).lengthLessThanOrEqual', expected, value);\n}\n\nexport function typedArrayLengthGreaterThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length > ${value}`;\n\treturn typedArrayLengthComparator(greaterThan, 's.typedArray(T).lengthGreaterThan', expected, value);\n}\n\nexport function typedArrayLengthGreaterThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length >= ${value}`;\n\treturn typedArrayLengthComparator(greaterThanOrEqual, 's.typedArray(T).lengthGreaterThanOrEqual', expected, value);\n}\n\nexport function typedArrayLengthEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length === ${value}`;\n\treturn typedArrayLengthComparator(equal, 's.typedArray(T).lengthEqual', expected, value);\n}\n\nexport function typedArrayLengthNotEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length !== ${value}`;\n\treturn typedArrayLengthComparator(notEqual, 's.typedArray(T).lengthNotEqual', expected, value);\n}\n\nexport function typedArrayLengthRange<T extends TypedArray>(start: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.length >= ${start} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.length >= start && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).lengthRange', 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayLengthRangeInclusive<T extends TypedArray>(start: number, end: number): IConstraint<T> {\n\tconst expected = `expected.length >= ${start} && expected.length <= ${end}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.length >= start && input.length <= end //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).lengthRangeInclusive', 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayLengthRangeExclusive<T extends TypedArray>(startAfter: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.length > ${startAfter} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.length > startAfter && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).lengthRangeExclusive', 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n","const vowels = ['a', 'e', 'i', 'o', 'u'];\n\nexport const aOrAn = (word: string) => {\n\treturn `${vowels.includes(word[0].toLowerCase()) ? 'an' : 'a'} ${word}`;\n};\n","export type TypedArray =\n\t| Int8Array\n\t| Uint8Array\n\t| Uint8ClampedArray\n\t| Int16Array\n\t| Uint16Array\n\t| Int32Array\n\t| Uint32Array\n\t| Float32Array\n\t| Float64Array\n\t| BigInt64Array\n\t| BigUint64Array;\n\nexport const TypedArrays = {\n\tInt8Array: (x: unknown): x is Int8Array => x instanceof Int8Array,\n\tUint8Array: (x: unknown): x is Uint8Array => x instanceof Uint8Array,\n\tUint8ClampedArray: (x: unknown): x is Uint8ClampedArray => x instanceof Uint8ClampedArray,\n\tInt16Array: (x: unknown): x is Int16Array => x instanceof Int16Array,\n\tUint16Array: (x: unknown): x is Uint16Array => x instanceof Uint16Array,\n\tInt32Array: (x: unknown): x is Int32Array => x instanceof Int32Array,\n\tUint32Array: (x: unknown): x is Uint32Array => x instanceof Uint32Array,\n\tFloat32Array: (x: unknown): x is Float32Array => x instanceof Float32Array,\n\tFloat64Array: (x: unknown): x is Float64Array => x instanceof Float64Array,\n\tBigInt64Array: (x: unknown): x is BigInt64Array => x instanceof BigInt64Array,\n\tBigUint64Array: (x: unknown): x is BigUint64Array => x instanceof BigUint64Array,\n\tTypedArray: (x: unknown): x is TypedArray => ArrayBuffer.isView(x) && !(x instanceof DataView)\n} as const;\n\nexport type TypedArrayName = keyof typeof TypedArrays;\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\ttypedArrayByteLengthEqual,\n\ttypedArrayByteLengthGreaterThan,\n\ttypedArrayByteLengthGreaterThanOrEqual,\n\ttypedArrayByteLengthLessThan,\n\ttypedArrayByteLengthLessThanOrEqual,\n\ttypedArrayByteLengthNotEqual,\n\ttypedArrayByteLengthRange,\n\ttypedArrayByteLengthRangeExclusive,\n\ttypedArrayByteLengthRangeInclusive,\n\ttypedArrayLengthEqual,\n\ttypedArrayLengthGreaterThan,\n\ttypedArrayLengthGreaterThanOrEqual,\n\ttypedArrayLengthLessThan,\n\ttypedArrayLengthLessThanOrEqual,\n\ttypedArrayLengthNotEqual,\n\ttypedArrayLengthRange,\n\ttypedArrayLengthRangeExclusive,\n\ttypedArrayLengthRangeInclusive\n} from '../constraints/TypedArrayLengthConstraints';\nimport { aOrAn } from '../constraints/util/common/vowels';\nimport { TypedArrays, type TypedArray, type TypedArrayName } from '../constraints/util/typedArray';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class TypedArrayValidator<T extends TypedArray> extends BaseValidator<T> {\n\tprivate readonly type: TypedArrayName;\n\n\tpublic constructor(type: TypedArrayName, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.type = type;\n\t}\n\n\tpublic byteLengthLessThan(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthLessThan(length));\n\t}\n\n\tpublic byteLengthLessThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthLessThanOrEqual(length));\n\t}\n\n\tpublic byteLengthGreaterThan(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthGreaterThan(length));\n\t}\n\n\tpublic byteLengthGreaterThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthGreaterThanOrEqual(length));\n\t}\n\n\tpublic byteLengthEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthEqual(length));\n\t}\n\n\tpublic byteLengthNotEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthNotEqual(length));\n\t}\n\n\tpublic byteLengthRange(start: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthRange(start, endBefore));\n\t}\n\n\tpublic byteLengthRangeInclusive(startAt: number, endAt: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthRangeInclusive(startAt, endAt) as IConstraint<T>);\n\t}\n\n\tpublic byteLengthRangeExclusive(startAfter: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthRangeExclusive(startAfter, endBefore));\n\t}\n\n\tpublic lengthLessThan(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthLessThan(length));\n\t}\n\n\tpublic lengthLessThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthLessThanOrEqual(length));\n\t}\n\n\tpublic lengthGreaterThan(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthGreaterThan(length));\n\t}\n\n\tpublic lengthGreaterThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthGreaterThanOrEqual(length));\n\t}\n\n\tpublic lengthEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthEqual(length));\n\t}\n\n\tpublic lengthNotEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthNotEqual(length));\n\t}\n\n\tpublic lengthRange(start: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayLengthRange(start, endBefore));\n\t}\n\n\tpublic lengthRangeInclusive(startAt: number, endAt: number) {\n\t\treturn this.addConstraint(typedArrayLengthRangeInclusive(startAt, endAt));\n\t}\n\n\tpublic lengthRangeExclusive(startAfter: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayLengthRangeExclusive(startAfter, endBefore));\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.type, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn TypedArrays[this.type](value)\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.typedArray', `Expected ${aOrAn(this.type)}`, value));\n\t}\n}\n","import type { TypedArray, TypedArrayName } from '../constraints/util/typedArray';\nimport type { Unwrap, UnwrapTuple } from '../lib/util-types';\nimport {\n\tArrayValidator,\n\tBaseValidator,\n\tBigIntValidator,\n\tBooleanValidator,\n\tDateValidator,\n\tInstanceValidator,\n\tLiteralValidator,\n\tMapValidator,\n\tNeverValidator,\n\tNullishValidator,\n\tNumberValidator,\n\tObjectValidator,\n\tPassthroughValidator,\n\tRecordValidator,\n\tSetValidator,\n\tStringValidator,\n\tTupleValidator,\n\tUnionValidator\n} from '../validators/imports';\nimport { LazyValidator } from '../validators/LazyValidator';\nimport { NativeEnumValidator, type NativeEnumLike } from '../validators/NativeEnumValidator';\nimport { TypedArrayValidator } from '../validators/TypedArrayValidator';\nimport type { Constructor, MappedObjectValidator } from './util-types';\n\nexport class Shapes {\n\tpublic get string() {\n\t\treturn new StringValidator();\n\t}\n\n\tpublic get number() {\n\t\treturn new NumberValidator();\n\t}\n\n\tpublic get bigint() {\n\t\treturn new BigIntValidator();\n\t}\n\n\tpublic get boolean() {\n\t\treturn new BooleanValidator();\n\t}\n\n\tpublic get date() {\n\t\treturn new DateValidator();\n\t}\n\n\tpublic object<T extends object>(shape: MappedObjectValidator<T>) {\n\t\treturn new ObjectValidator<T>(shape);\n\t}\n\n\tpublic get undefined() {\n\t\treturn this.literal(undefined);\n\t}\n\n\tpublic get null() {\n\t\treturn this.literal(null);\n\t}\n\n\tpublic get nullish() {\n\t\treturn new NullishValidator();\n\t}\n\n\tpublic get any() {\n\t\treturn new PassthroughValidator<any>();\n\t}\n\n\tpublic get unknown() {\n\t\treturn new PassthroughValidator<unknown>();\n\t}\n\n\tpublic get never() {\n\t\treturn new NeverValidator();\n\t}\n\n\tpublic enum<T>(...values: readonly T[]) {\n\t\treturn this.union(...values.map((value) => this.literal(value)));\n\t}\n\n\tpublic nativeEnum<T extends NativeEnumLike>(enumShape: T): NativeEnumValidator<T> {\n\t\treturn new NativeEnumValidator(enumShape);\n\t}\n\n\tpublic literal<T>(value: T): BaseValidator<T> {\n\t\tif (value instanceof Date) return this.date.equal(value) as unknown as BaseValidator<T>;\n\t\treturn new LiteralValidator(value);\n\t}\n\n\tpublic instance<T>(expected: Constructor<T>): InstanceValidator<T> {\n\t\treturn new InstanceValidator(expected);\n\t}\n\n\tpublic union<T extends [...BaseValidator<any>[]]>(...validators: [...T]): UnionValidator<Unwrap<T[number]>> {\n\t\treturn new UnionValidator(validators);\n\t}\n\n\tpublic array<T>(validator: BaseValidator<T[][number]>): ArrayValidator<T[], T[][number]>;\n\tpublic array<T extends unknown[]>(validator: BaseValidator<T[number]>): ArrayValidator<T, T[number]>;\n\tpublic array<T extends unknown[]>(validator: BaseValidator<T[number]>) {\n\t\treturn new ArrayValidator(validator);\n\t}\n\n\tpublic typedArray<T extends TypedArray>(type: TypedArrayName = 'TypedArray') {\n\t\treturn new TypedArrayValidator<T>(type);\n\t}\n\n\tpublic get int8Array() {\n\t\treturn this.typedArray<Int8Array>('Int8Array');\n\t}\n\n\tpublic get uint8Array() {\n\t\treturn this.typedArray<Uint8Array>('Uint8Array');\n\t}\n\n\tpublic get uint8ClampedArray() {\n\t\treturn this.typedArray<Uint8ClampedArray>('Uint8ClampedArray');\n\t}\n\n\tpublic get int16Array() {\n\t\treturn this.typedArray<Int16Array>('Int16Array');\n\t}\n\n\tpublic get uint16Array() {\n\t\treturn this.typedArray<Uint16Array>('Uint16Array');\n\t}\n\n\tpublic get int32Array() {\n\t\treturn this.typedArray<Int32Array>('Int32Array');\n\t}\n\n\tpublic get uint32Array() {\n\t\treturn this.typedArray<Uint32Array>('Uint32Array');\n\t}\n\n\tpublic get float32Array() {\n\t\treturn this.typedArray<Float32Array>('Float32Array');\n\t}\n\n\tpublic get float64Array() {\n\t\treturn this.typedArray<Float64Array>('Float64Array');\n\t}\n\n\tpublic get bigInt64Array() {\n\t\treturn this.typedArray<BigInt64Array>('BigInt64Array');\n\t}\n\n\tpublic get bigUint64Array() {\n\t\treturn this.typedArray<BigUint64Array>('BigUint64Array');\n\t}\n\n\tpublic tuple<T extends [...BaseValidator<any>[]]>(validators: [...T]): TupleValidator<UnwrapTuple<T>> {\n\t\treturn new TupleValidator(validators);\n\t}\n\n\tpublic set<T>(validator: BaseValidator<T>) {\n\t\treturn new SetValidator(validator);\n\t}\n\n\tpublic record<T>(validator: BaseValidator<T>) {\n\t\treturn new RecordValidator(validator);\n\t}\n\n\tpublic map<T, U>(keyValidator: BaseValidator<T>, valueValidator: BaseValidator<U>) {\n\t\treturn new MapValidator(keyValidator, valueValidator);\n\t}\n\n\tpublic lazy<T extends BaseValidator<unknown>>(validator: (value: unknown) => T) {\n\t\treturn new LazyValidator(validator);\n\t}\n}\n","import { Shapes } from './lib/Shapes';\n\nexport const s = new Shapes();\n\nexport * from './lib/Result';\nexport * from './lib/configs';\nexport * from './lib/errors/BaseError';\nexport * from './lib/errors/CombinedError';\nexport * from './lib/errors/CombinedPropertyError';\nexport * from './lib/errors/ExpectedConstraintError';\nexport * from './lib/errors/ExpectedValidationError';\nexport * from './lib/errors/MissingPropertyError';\nexport * from './lib/errors/MultiplePossibilitiesConstraintError';\nexport * from './lib/errors/UnknownEnumValueError';\nexport * from './lib/errors/UnknownPropertyError';\nexport * from './lib/errors/ValidationError';\nexport * from './type-exports';\n"]}
\ No newline at end of file diff --git a/node_modules/@sapphire/shapeshift/dist/index.js b/node_modules/@sapphire/shapeshift/dist/index.js new file mode 100644 index 0000000..42f256f --- /dev/null +++ b/node_modules/@sapphire/shapeshift/dist/index.js @@ -0,0 +1,2242 @@ +'use strict'; + +var get = require('lodash/get.js'); +var util = require('util'); +var fastDeepEqual = require('fast-deep-equal/es6/index.js'); +var uniqWith = require('lodash/uniqWith.js'); + +function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; } + +var get__default = /*#__PURE__*/_interopDefault(get); +var fastDeepEqual__default = /*#__PURE__*/_interopDefault(fastDeepEqual); +var uniqWith__default = /*#__PURE__*/_interopDefault(uniqWith); + +var __defProp = Object.defineProperty; +var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); + +// 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/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 = util.inspect(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((k) => get__default.default(parent, k)) : get__default.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((v, constraint) => constraint.run(v).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"); +function isUnique(input) { + if (input.length < 2) + return true; + const uniqueArray2 = uniqWith__default.default(input, fastDeepEqual__default.default); + return uniqueArray2.length === input.length; +} +__name(isUnique, "isUnique"); + +// src/constraints/util/operators.ts +function lessThan(a, b) { + return a < b; +} +__name(lessThan, "lessThan"); +function lessThanOrEqual(a, b) { + return a <= b; +} +__name(lessThanOrEqual, "lessThanOrEqual"); +function greaterThan(a, b) { + return a > b; +} +__name(greaterThan, "greaterThan"); +function greaterThanOrEqual(a, b) { + return a >= b; +} +__name(greaterThanOrEqual, "greaterThanOrEqual"); +function equal(a, b) { + return a === b; +} +__name(equal, "equal"); +function notEqual(a, b) { + return a !== b; +} +__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"); +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 = util.inspect(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 i = 0; i < values.length; i++) { + const result = this.validator.run(values[i]); + if (result.isOk()) + transformed.push(result.value); + else + errors.push([i, 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"); +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 = util.inspect(this.expected, newOptions).replace(/\n/g, padding); + const given = util.inspect(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"); +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 = util.inspect(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, i) => { + const index = options.stylize((i + 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(s2) { + return IPv4Reg.test(s2); +} +__name(isIPv4, "isIPv4"); +function isIPv6(s2) { + return IPv6Reg.test(s2); +} +__name(isIPv6, "isIPv6"); +function isIP(s2) { + if (isIPv4(s2)) + return 4; + if (isIPv6(s2)) + 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"); +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 = util.inspect(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 i = 0; i < values.length; i++) { + const result = this.validators[i].run(values[i]); + if (result.isOk()) + transformed.push(result.value); + else + errors.push([i, 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: (x) => x instanceof Int8Array, + Uint8Array: (x) => x instanceof Uint8Array, + Uint8ClampedArray: (x) => x instanceof Uint8ClampedArray, + Int16Array: (x) => x instanceof Int16Array, + Uint16Array: (x) => x instanceof Uint16Array, + Int32Array: (x) => x instanceof Int32Array, + Uint32Array: (x) => x instanceof Uint32Array, + Float32Array: (x) => x instanceof Float32Array, + Float64Array: (x) => x instanceof Float64Array, + BigInt64Array: (x) => x instanceof BigInt64Array, + BigUint64Array: (x) => x instanceof BigUint64Array, + TypedArray: (x) => ArrayBuffer.isView(x) && !(x 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 s = 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 = s; +exports.setGlobalValidationEnabled = setGlobalValidationEnabled; +//# sourceMappingURL=out.js.map +//# sourceMappingURL=index.js.map
\ No newline at end of file diff --git a/node_modules/@sapphire/shapeshift/dist/index.js.map b/node_modules/@sapphire/shapeshift/dist/index.js.map new file mode 100644 index 0000000..46db7f3 --- /dev/null +++ b/node_modules/@sapphire/shapeshift/dist/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../src/lib/configs.ts","../src/lib/Result.ts","../src/validators/util/getValue.ts","../src/constraints/ObjectConstrains.ts","../src/lib/errors/ExpectedConstraintError.ts","../src/lib/errors/BaseError.ts","../src/lib/errors/BaseConstraintError.ts","../src/validators/BaseValidator.ts","../src/constraints/util/isUnique.ts","../src/constraints/util/operators.ts","../src/constraints/ArrayConstraints.ts","../src/lib/errors/CombinedPropertyError.ts","../src/lib/errors/ValidationError.ts","../src/validators/ArrayValidator.ts","../src/constraints/BigIntConstraints.ts","../src/validators/BigIntValidator.ts","../src/constraints/BooleanConstraints.ts","../src/validators/BooleanValidator.ts","../src/constraints/DateConstraints.ts","../src/validators/DateValidator.ts","../src/lib/errors/ExpectedValidationError.ts","../src/validators/InstanceValidator.ts","../src/validators/LiteralValidator.ts","../src/validators/NeverValidator.ts","../src/validators/NullishValidator.ts","../src/constraints/NumberConstraints.ts","../src/validators/NumberValidator.ts","../src/lib/errors/MissingPropertyError.ts","../src/lib/errors/UnknownPropertyError.ts","../src/validators/DefaultValidator.ts","../src/lib/errors/CombinedError.ts","../src/validators/UnionValidator.ts","../src/validators/ObjectValidator.ts","../src/validators/PassthroughValidator.ts","../src/validators/RecordValidator.ts","../src/validators/SetValidator.ts","../src/constraints/util/emailValidator.ts","../src/constraints/util/net.ts","../src/constraints/util/phoneValidator.ts","../src/lib/errors/MultiplePossibilitiesConstraintError.ts","../src/constraints/util/common/combinedResultFn.ts","../src/constraints/util/urlValidators.ts","../src/constraints/StringConstraints.ts","../src/validators/StringValidator.ts","../src/validators/TupleValidator.ts","../src/validators/MapValidator.ts","../src/validators/LazyValidator.ts","../src/lib/errors/UnknownEnumValueError.ts","../src/validators/NativeEnumValidator.ts","../src/constraints/TypedArrayLengthConstraints.ts","../src/constraints/util/common/vowels.ts","../src/constraints/util/typedArray.ts","../src/validators/TypedArrayValidator.ts","../src/lib/Shapes.ts","../src/index.ts"],"names":["uniqueArray","inspect","value","s"],"mappings":"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","sourcesContent":["let validationEnabled = true;\n\n/**\n * Sets whether validators should run on the input, or if the input should be passed through.\n * @param enabled Whether validation should be done on inputs\n */\nexport function setGlobalValidationEnabled(enabled: boolean) {\n\tvalidationEnabled = enabled;\n}\n\n/**\n * @returns Whether validation is enabled\n */\nexport function getGlobalValidationEnabled() {\n\treturn validationEnabled;\n}\n","export class Result<T, E extends Error = Error> {\n\tpublic readonly success: boolean;\n\tpublic readonly value?: T;\n\tpublic readonly error?: E;\n\n\tprivate constructor(success: boolean, value?: T, error?: E) {\n\t\tthis.success = success;\n\t\tif (success) {\n\t\t\tthis.value = value;\n\t\t} else {\n\t\t\tthis.error = error;\n\t\t}\n\t}\n\n\tpublic isOk(): this is { success: true; value: T } {\n\t\treturn this.success;\n\t}\n\n\tpublic isErr(): this is { success: false; error: E } {\n\t\treturn !this.success;\n\t}\n\n\tpublic unwrap(): T {\n\t\tif (this.isOk()) return this.value;\n\t\tthrow this.error as Error;\n\t}\n\n\tpublic static ok<T, E extends Error = Error>(value: T): Result<T, E> {\n\t\treturn new Result<T, E>(true, value);\n\t}\n\n\tpublic static err<T, E extends Error = Error>(error: E): Result<T, E> {\n\t\treturn new Result<T, E>(false, undefined, error);\n\t}\n}\n","// https://github.com/microsoft/TypeScript/issues/37663\ntype Fn = (...args: unknown[]) => unknown;\n\nexport function getValue<T, U = T extends Fn ? ReturnType<T> : T>(valueOrFn: T): U {\n\treturn typeof valueOrFn === 'function' ? valueOrFn() : valueOrFn;\n}\n","import get from 'lodash/get.js';\nimport { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { BaseValidator } from '../type-exports';\nimport type { IConstraint } from './type-exports';\n\nexport type ObjectConstraintName = `s.object(T.when)`;\n\nexport type WhenKey = PropertyKey | PropertyKey[];\n\nexport interface WhenOptions<T extends BaseValidator<any>, Key extends WhenKey> {\n\tis?: boolean | ((value: Key extends Array<any> ? any[] : any) => boolean);\n\tthen: (predicate: T) => T;\n\totherwise?: (predicate: T) => T;\n}\n\nexport function whenConstraint<T extends BaseValidator<any>, I, Key extends WhenKey>(\n\tkey: Key,\n\toptions: WhenOptions<T, Key>,\n\tvalidator: T\n): IConstraint<I> {\n\treturn {\n\t\trun(input: I, parent?: any) {\n\t\t\tif (!parent) {\n\t\t\t\treturn Result.err(new ExpectedConstraintError('s.object(T.when)', 'Validator has no parent', parent, 'Validator to have a parent'));\n\t\t\t}\n\n\t\t\tconst isKeyArray = Array.isArray(key);\n\n\t\t\tconst value = isKeyArray ? key.map((k) => get(parent, k)) : get(parent, key);\n\n\t\t\tconst predicate = resolveBooleanIs<T, Key>(options, value, isKeyArray) ? options.then : options.otherwise;\n\n\t\t\tif (predicate) {\n\t\t\t\treturn predicate(validator).run(input) as Result<I, ExpectedConstraintError<I>>;\n\t\t\t}\n\n\t\t\treturn Result.ok(input);\n\t\t}\n\t};\n}\n\nfunction resolveBooleanIs<T extends BaseValidator<any>, Key extends WhenKey>(options: WhenOptions<T, Key>, value: any, isKeyArray: boolean) {\n\tif (options.is === undefined) {\n\t\treturn isKeyArray ? !value.some((val: any) => !val) : Boolean(value);\n\t}\n\n\tif (typeof options.is === 'function') {\n\t\treturn options.is(value);\n\t}\n\n\treturn value === options.is;\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { customInspectSymbolStackLess } from './BaseError';\nimport { BaseConstraintError, type ConstraintErrorNames } from './BaseConstraintError';\n\nexport class ExpectedConstraintError<T = unknown> extends BaseConstraintError<T> {\n\tpublic readonly expected: string;\n\n\tpublic constructor(constraint: ConstraintErrorNames, message: string, given: T, expected: string) {\n\t\tsuper(constraint, message, given);\n\t\tthis.expected = expected;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tconstraint: this.constraint,\n\t\t\tgiven: this.given,\n\t\t\texpected: this.expected\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst constraint = options.stylize(this.constraint, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[ExpectedConstraintError: ${constraint}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1 };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('ExpectedConstraintError', 'special')} > ${constraint}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst expectedBlock = `\\n ${options.stylize('Expected: ', 'string')}${options.stylize(this.expected, 'boolean')}`;\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${expectedBlock}\\n${givenBlock}`;\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\n\nexport const customInspectSymbol = Symbol.for('nodejs.util.inspect.custom');\nexport const customInspectSymbolStackLess = Symbol.for('nodejs.util.inspect.custom.stack-less');\n\nexport abstract class BaseError extends Error {\n\tprotected [customInspectSymbol](depth: number, options: InspectOptionsStylized) {\n\t\treturn `${this[customInspectSymbolStackLess](depth, options)}\\n${this.stack!.slice(this.stack!.indexOf('\\n'))}`;\n\t}\n\n\tprotected abstract [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string;\n}\n","import type {\n\tArrayConstraintName,\n\tBigIntConstraintName,\n\tBooleanConstraintName,\n\tDateConstraintName,\n\tNumberConstraintName,\n\tObjectConstraintName,\n\tStringConstraintName,\n\tTypedArrayConstraintName\n} from '../../constraints/type-exports';\nimport { BaseError } from './BaseError';\n\nexport type ConstraintErrorNames =\n\t| TypedArrayConstraintName\n\t| ArrayConstraintName\n\t| BigIntConstraintName\n\t| BooleanConstraintName\n\t| DateConstraintName\n\t| NumberConstraintName\n\t| ObjectConstraintName\n\t| StringConstraintName;\n\nexport abstract class BaseConstraintError<T = unknown> extends BaseError {\n\tpublic readonly constraint: ConstraintErrorNames;\n\tpublic readonly given: T;\n\n\tpublic constructor(constraint: ConstraintErrorNames, message: string, given: T) {\n\t\tsuper(message);\n\t\tthis.constraint = constraint;\n\t\tthis.given = given;\n\t}\n}\n","import { getGlobalValidationEnabled } from '../lib/configs';\nimport { Result } from '../lib/Result';\nimport { ArrayValidator, DefaultValidator, LiteralValidator, NullishValidator, SetValidator, UnionValidator } from './imports';\nimport { getValue } from './util/getValue';\nimport { whenConstraint, type WhenKey, type WhenOptions } from '../constraints/ObjectConstrains';\nimport type { CombinedError } from '../lib/errors/CombinedError';\nimport type { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport type { UnknownEnumValueError } from '../lib/errors/UnknownEnumValueError';\nimport type { ValidationError } from '../lib/errors/ValidationError';\nimport type { BaseConstraintError, InferResultType } from '../type-exports';\nimport type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\n\nexport abstract class BaseValidator<T> {\n\tpublic description?: string;\n\tprotected parent?: object;\n\tprotected constraints: readonly IConstraint<T>[] = [];\n\tprotected isValidationEnabled: boolean | (() => boolean) | null = null;\n\n\tpublic constructor(constraints: readonly IConstraint<T>[] = []) {\n\t\tthis.constraints = constraints;\n\t}\n\n\tpublic setParent(parent: object): this {\n\t\tthis.parent = parent;\n\t\treturn this;\n\t}\n\n\tpublic get optional(): UnionValidator<T | undefined> {\n\t\treturn new UnionValidator([new LiteralValidator(undefined), this.clone()]);\n\t}\n\n\tpublic get nullable(): UnionValidator<T | null> {\n\t\treturn new UnionValidator([new LiteralValidator(null), this.clone()]);\n\t}\n\n\tpublic get nullish(): UnionValidator<T | null | undefined> {\n\t\treturn new UnionValidator([new NullishValidator(), this.clone()]);\n\t}\n\n\tpublic get array(): ArrayValidator<T[]> {\n\t\treturn new ArrayValidator<T[]>(this.clone());\n\t}\n\n\tpublic get set(): SetValidator<T> {\n\t\treturn new SetValidator<T>(this.clone());\n\t}\n\n\tpublic or<O>(...predicates: readonly BaseValidator<O>[]): UnionValidator<T | O> {\n\t\treturn new UnionValidator<T | O>([this.clone(), ...predicates]);\n\t}\n\n\tpublic transform(cb: (value: T) => T): this;\n\tpublic transform<O>(cb: (value: T) => O): BaseValidator<O>;\n\tpublic transform<O>(cb: (value: T) => O): BaseValidator<O> {\n\t\treturn this.addConstraint({ run: (input) => Result.ok(cb(input) as unknown as T) }) as unknown as BaseValidator<O>;\n\t}\n\n\tpublic reshape(cb: (input: T) => Result<T>): this;\n\tpublic reshape<R extends Result<unknown>, O = InferResultType<R>>(cb: (input: T) => R): BaseValidator<O>;\n\tpublic reshape<R extends Result<unknown>, O = InferResultType<R>>(cb: (input: T) => R): BaseValidator<O> {\n\t\treturn this.addConstraint({ run: cb as unknown as (input: T) => Result<T, BaseConstraintError<T>> }) as unknown as BaseValidator<O>;\n\t}\n\n\tpublic default(value: Exclude<T, undefined> | (() => Exclude<T, undefined>)): DefaultValidator<Exclude<T, undefined>> {\n\t\treturn new DefaultValidator(this.clone() as unknown as BaseValidator<Exclude<T, undefined>>, value);\n\t}\n\n\tpublic when<Key extends WhenKey, This extends BaseValidator<any> = this>(key: Key, options: WhenOptions<This, Key>): this {\n\t\treturn this.addConstraint(whenConstraint<This, T, Key>(key, options, this as unknown as This));\n\t}\n\n\tpublic describe(description: string): this {\n\t\tconst clone = this.clone();\n\t\tclone.description = description;\n\t\treturn clone;\n\t}\n\n\tpublic run(value: unknown): Result<T, BaseError> {\n\t\tlet result = this.handle(value) as Result<T, BaseError>;\n\t\tif (result.isErr()) return result;\n\n\t\tfor (const constraint of this.constraints) {\n\t\t\tresult = constraint.run(result.value as T, this.parent);\n\t\t\tif (result.isErr()) break;\n\t\t}\n\n\t\treturn result;\n\t}\n\n\tpublic parse<R extends T = T>(value: unknown): R {\n\t\t// If validation is disabled (at the validator or global level), we only run the `handle` method, which will do some basic checks\n\t\t// (like that the input is a string for a string validator)\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn this.handle(value).unwrap() as R;\n\t\t}\n\n\t\treturn this.constraints.reduce((v, constraint) => constraint.run(v).unwrap(), this.handle(value).unwrap()) as R;\n\t}\n\n\tpublic is<R extends T = T>(value: unknown): value is R {\n\t\treturn this.run(value).isOk();\n\t}\n\n\t/**\n\t * Sets if the validator should also run constraints or just do basic checks.\n\t * @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.\n\t * Set to `null` to go off of the global configuration.\n\t */\n\tpublic setValidationEnabled(isValidationEnabled: boolean | (() => boolean) | null): this {\n\t\tconst clone = this.clone();\n\t\tclone.isValidationEnabled = isValidationEnabled;\n\t\treturn clone;\n\t}\n\n\tpublic getValidationEnabled() {\n\t\treturn getValue(this.isValidationEnabled);\n\t}\n\n\tprotected get shouldRunConstraints(): boolean {\n\t\treturn getValue(this.isValidationEnabled) ?? getGlobalValidationEnabled();\n\t}\n\n\tprotected clone(): this {\n\t\tconst clone: this = Reflect.construct(this.constructor, [this.constraints]);\n\t\tclone.isValidationEnabled = this.isValidationEnabled;\n\t\treturn clone;\n\t}\n\n\tprotected abstract handle(value: unknown): Result<T, ValidatorError>;\n\n\tprotected addConstraint(constraint: IConstraint<T>): this {\n\t\tconst clone = this.clone();\n\t\tclone.constraints = clone.constraints.concat(constraint);\n\t\treturn clone;\n\t}\n}\n\nexport type ValidatorError = ValidationError | CombinedError | CombinedPropertyError | UnknownEnumValueError;\n","import fastDeepEqual from 'fast-deep-equal/es6/index.js';\nimport uniqWith from 'lodash/uniqWith.js';\n\nexport function isUnique(input: unknown[]) {\n\tif (input.length < 2) return true;\n\tconst uniqueArray = uniqWith(input, fastDeepEqual);\n\treturn uniqueArray.length === input.length;\n}\n","export function lessThan(a: number, b: number): boolean;\nexport function lessThan(a: bigint, b: bigint): boolean;\nexport function lessThan(a: number | bigint, b: number | bigint): boolean {\n\treturn a < b;\n}\n\nexport function lessThanOrEqual(a: number, b: number): boolean;\nexport function lessThanOrEqual(a: bigint, b: bigint): boolean;\nexport function lessThanOrEqual(a: number | bigint, b: number | bigint): boolean {\n\treturn a <= b;\n}\n\nexport function greaterThan(a: number, b: number): boolean;\nexport function greaterThan(a: bigint, b: bigint): boolean;\nexport function greaterThan(a: number | bigint, b: number | bigint): boolean {\n\treturn a > b;\n}\n\nexport function greaterThanOrEqual(a: number, b: number): boolean;\nexport function greaterThanOrEqual(a: bigint, b: bigint): boolean;\nexport function greaterThanOrEqual(a: number | bigint, b: number | bigint): boolean {\n\treturn a >= b;\n}\n\nexport function equal(a: number, b: number): boolean;\nexport function equal(a: bigint, b: bigint): boolean;\nexport function equal(a: number | bigint, b: number | bigint): boolean {\n\treturn a === b;\n}\n\nexport function notEqual(a: number, b: number): boolean;\nexport function notEqual(a: bigint, b: bigint): boolean;\nexport function notEqual(a: number | bigint, b: number | bigint): boolean {\n\treturn a !== b;\n}\n\nexport interface Comparator {\n\t(a: number, b: number): boolean;\n\t(a: bigint, b: bigint): boolean;\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { isUnique } from './util/isUnique';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type ArrayConstraintName = `s.array(T).${\n\t| 'unique'\n\t| `length${\n\t\t\t| 'LessThan'\n\t\t\t| 'LessThanOrEqual'\n\t\t\t| 'GreaterThan'\n\t\t\t| 'GreaterThanOrEqual'\n\t\t\t| 'Equal'\n\t\t\t| 'NotEqual'\n\t\t\t| 'Range'\n\t\t\t| 'RangeInclusive'\n\t\t\t| 'RangeExclusive'}`}`;\n\nfunction arrayLengthComparator<T>(comparator: Comparator, name: ArrayConstraintName, expected: string, length: number): IConstraint<T[]> {\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn comparator(input.length, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function arrayLengthLessThan<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length < ${value}`;\n\treturn arrayLengthComparator(lessThan, 's.array(T).lengthLessThan', expected, value);\n}\n\nexport function arrayLengthLessThanOrEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length <= ${value}`;\n\treturn arrayLengthComparator(lessThanOrEqual, 's.array(T).lengthLessThanOrEqual', expected, value);\n}\n\nexport function arrayLengthGreaterThan<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length > ${value}`;\n\treturn arrayLengthComparator(greaterThan, 's.array(T).lengthGreaterThan', expected, value);\n}\n\nexport function arrayLengthGreaterThanOrEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length >= ${value}`;\n\treturn arrayLengthComparator(greaterThanOrEqual, 's.array(T).lengthGreaterThanOrEqual', expected, value);\n}\n\nexport function arrayLengthEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length === ${value}`;\n\treturn arrayLengthComparator(equal, 's.array(T).lengthEqual', expected, value);\n}\n\nexport function arrayLengthNotEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length !== ${value}`;\n\treturn arrayLengthComparator(notEqual, 's.array(T).lengthNotEqual', expected, value);\n}\n\nexport function arrayLengthRange<T>(start: number, endBefore: number): IConstraint<T[]> {\n\tconst expected = `expected.length >= ${start} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn input.length >= start && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).lengthRange', 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function arrayLengthRangeInclusive<T>(start: number, end: number): IConstraint<T[]> {\n\tconst expected = `expected.length >= ${start} && expected.length <= ${end}`;\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn input.length >= start && input.length <= end //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).lengthRangeInclusive', 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function arrayLengthRangeExclusive<T>(startAfter: number, endBefore: number): IConstraint<T[]> {\n\tconst expected = `expected.length > ${startAfter} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn input.length > startAfter && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).lengthRangeExclusive', 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport const uniqueArray: IConstraint<unknown[]> = {\n\trun(input: unknown[]) {\n\t\treturn isUnique(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).unique', 'Array values are not unique', input, 'Expected all values to be unique'));\n\t}\n};\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class CombinedPropertyError extends BaseError {\n\tpublic readonly errors: [PropertyKey, BaseError][];\n\n\tpublic constructor(errors: [PropertyKey, BaseError][]) {\n\t\tsuper('Received one or more errors');\n\n\t\tthis.errors = errors;\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize('[CombinedPropertyError]', 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\n\t\tconst header = `${options.stylize('CombinedPropertyError', 'special')} (${options.stylize(this.errors.length.toString(), 'number')})`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst errors = this.errors\n\t\t\t.map(([key, error]) => {\n\t\t\t\tconst property = CombinedPropertyError.formatProperty(key, options);\n\t\t\t\tconst body = error[customInspectSymbolStackLess](depth - 1, newOptions).replace(/\\n/g, padding);\n\n\t\t\t\treturn ` input${property}${padding}${body}`;\n\t\t\t})\n\t\t\t.join('\\n\\n');\n\t\treturn `${header}\\n ${message}\\n\\n${errors}`;\n\t}\n\n\tprivate static formatProperty(key: PropertyKey, options: InspectOptionsStylized): string {\n\t\tif (typeof key === 'string') return options.stylize(`.${key}`, 'symbol');\n\t\tif (typeof key === 'number') return `[${options.stylize(key.toString(), 'number')}]`;\n\t\treturn `[${options.stylize('Symbol', 'symbol')}(${key.description})]`;\n\t}\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class ValidationError extends BaseError {\n\tpublic readonly validator: string;\n\tpublic readonly given: unknown;\n\n\tpublic constructor(validator: string, message: string, given: unknown) {\n\t\tsuper(message);\n\n\t\tthis.validator = validator;\n\t\tthis.given = given;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tvalidator: this.validator,\n\t\t\tgiven: this.given\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst validator = options.stylize(this.validator, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[ValidationError: ${validator}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('ValidationError', 'special')} > ${validator}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${givenBlock}`;\n\t}\n}\n","import {\n\tarrayLengthEqual,\n\tarrayLengthGreaterThan,\n\tarrayLengthGreaterThanOrEqual,\n\tarrayLengthLessThan,\n\tarrayLengthLessThanOrEqual,\n\tarrayLengthNotEqual,\n\tarrayLengthRange,\n\tarrayLengthRangeExclusive,\n\tarrayLengthRangeInclusive,\n\tuniqueArray\n} from '../constraints/ArrayConstraints';\nimport type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport type { ExpandSmallerTuples, Tuple, UnshiftTuple } from '../lib/util-types';\nimport { BaseValidator } from './imports';\n\nexport class ArrayValidator<T extends unknown[], I = T[number]> extends BaseValidator<T> {\n\tprivate readonly validator: BaseValidator<I>;\n\n\tpublic constructor(validator: BaseValidator<I>, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tpublic lengthLessThan<N extends number>(length: N): ArrayValidator<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, N>]>>> {\n\t\treturn this.addConstraint(arrayLengthLessThan(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthLessThanOrEqual<N extends number>(length: N): ArrayValidator<ExpandSmallerTuples<[...Tuple<I, N>]>> {\n\t\treturn this.addConstraint(arrayLengthLessThanOrEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthGreaterThan<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>, I, ...T]> {\n\t\treturn this.addConstraint(arrayLengthGreaterThan(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthGreaterThanOrEqual<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>, ...T]> {\n\t\treturn this.addConstraint(arrayLengthGreaterThanOrEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthEqual<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>]> {\n\t\treturn this.addConstraint(arrayLengthEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthNotEqual(length: number): ArrayValidator<[...T]> {\n\t\treturn this.addConstraint(arrayLengthNotEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthRange<S extends number, E extends number>(\n\t\tstart: S,\n\t\tendBefore: E\n\t): ArrayValidator<Exclude<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, E>]>>, ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, S>]>>>> {\n\t\treturn this.addConstraint(arrayLengthRange(start, endBefore) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthRangeInclusive<S extends number, E extends number>(\n\t\tstartAt: S,\n\t\tendAt: E\n\t): ArrayValidator<Exclude<ExpandSmallerTuples<[...Tuple<I, E>]>, ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, S>]>>>> {\n\t\treturn this.addConstraint(arrayLengthRangeInclusive(startAt, endAt) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthRangeExclusive<S extends number, E extends number>(\n\t\tstartAfter: S,\n\t\tendBefore: E\n\t): ArrayValidator<Exclude<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, E>]>>, ExpandSmallerTuples<[...Tuple<T, S>]>>> {\n\t\treturn this.addConstraint(arrayLengthRangeExclusive(startAfter, endBefore) as IConstraint<T>) as any;\n\t}\n\n\tpublic get unique(): this {\n\t\treturn this.addConstraint(uniqueArray as IConstraint<T>);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<T, ValidationError | CombinedPropertyError> {\n\t\tif (!Array.isArray(values)) {\n\t\t\treturn Result.err(new ValidationError('s.array(T)', 'Expected an array', values));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(values as T);\n\t\t}\n\n\t\tconst errors: [number, BaseError][] = [];\n\t\tconst transformed: T = [] as unknown as T;\n\n\t\tfor (let i = 0; i < values.length; i++) {\n\t\t\tconst result = this.validator.run(values[i]);\n\t\t\tif (result.isOk()) transformed.push(result.value);\n\t\t\telse errors.push([i, result.error!]);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type BigIntConstraintName = `s.bigint.${\n\t| 'lessThan'\n\t| 'lessThanOrEqual'\n\t| 'greaterThan'\n\t| 'greaterThanOrEqual'\n\t| 'equal'\n\t| 'notEqual'\n\t| 'divisibleBy'}`;\n\nfunction bigintComparator(comparator: Comparator, name: BigIntConstraintName, expected: string, number: bigint): IConstraint<bigint> {\n\treturn {\n\t\trun(input: bigint) {\n\t\t\treturn comparator(input, number) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid bigint value', input, expected));\n\t\t}\n\t};\n}\n\nexport function bigintLessThan(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected < ${value}n`;\n\treturn bigintComparator(lessThan, 's.bigint.lessThan', expected, value);\n}\n\nexport function bigintLessThanOrEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected <= ${value}n`;\n\treturn bigintComparator(lessThanOrEqual, 's.bigint.lessThanOrEqual', expected, value);\n}\n\nexport function bigintGreaterThan(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected > ${value}n`;\n\treturn bigintComparator(greaterThan, 's.bigint.greaterThan', expected, value);\n}\n\nexport function bigintGreaterThanOrEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected >= ${value}n`;\n\treturn bigintComparator(greaterThanOrEqual, 's.bigint.greaterThanOrEqual', expected, value);\n}\n\nexport function bigintEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected === ${value}n`;\n\treturn bigintComparator(equal, 's.bigint.equal', expected, value);\n}\n\nexport function bigintNotEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected !== ${value}n`;\n\treturn bigintComparator(notEqual, 's.bigint.notEqual', expected, value);\n}\n\nexport function bigintDivisibleBy(divider: bigint): IConstraint<bigint> {\n\tconst expected = `expected % ${divider}n === 0n`;\n\treturn {\n\t\trun(input: bigint) {\n\t\t\treturn input % divider === 0n //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.bigint.divisibleBy', 'BigInt is not divisible', input, expected));\n\t\t}\n\t};\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\tbigintDivisibleBy,\n\tbigintEqual,\n\tbigintGreaterThan,\n\tbigintGreaterThanOrEqual,\n\tbigintLessThan,\n\tbigintLessThanOrEqual,\n\tbigintNotEqual\n} from '../constraints/BigIntConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class BigIntValidator<T extends bigint> extends BaseValidator<T> {\n\tpublic lessThan(number: bigint): this {\n\t\treturn this.addConstraint(bigintLessThan(number) as IConstraint<T>);\n\t}\n\n\tpublic lessThanOrEqual(number: bigint): this {\n\t\treturn this.addConstraint(bigintLessThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThan(number: bigint): this {\n\t\treturn this.addConstraint(bigintGreaterThan(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThanOrEqual(number: bigint): this {\n\t\treturn this.addConstraint(bigintGreaterThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic equal<N extends bigint>(number: N): BigIntValidator<N> {\n\t\treturn this.addConstraint(bigintEqual(number) as IConstraint<T>) as unknown as BigIntValidator<N>;\n\t}\n\n\tpublic notEqual(number: bigint): this {\n\t\treturn this.addConstraint(bigintNotEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic get positive(): this {\n\t\treturn this.greaterThanOrEqual(0n);\n\t}\n\n\tpublic get negative(): this {\n\t\treturn this.lessThan(0n);\n\t}\n\n\tpublic divisibleBy(number: bigint): this {\n\t\treturn this.addConstraint(bigintDivisibleBy(number) as IConstraint<T>);\n\t}\n\n\tpublic get abs(): this {\n\t\treturn this.transform((value) => (value < 0 ? -value : value) as T);\n\t}\n\n\tpublic intN(bits: number): this {\n\t\treturn this.transform((value) => BigInt.asIntN(bits, value) as T);\n\t}\n\n\tpublic uintN(bits: number): this {\n\t\treturn this.transform((value) => BigInt.asUintN(bits, value) as T);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'bigint' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.bigint', 'Expected a bigint primitive', value));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\n\nexport type BooleanConstraintName = `s.boolean.${boolean}`;\n\nexport const booleanTrue: IConstraint<boolean, true> = {\n\trun(input: boolean) {\n\t\treturn input //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.boolean.true', 'Invalid boolean value', input, 'true'));\n\t}\n};\n\nexport const booleanFalse: IConstraint<boolean, false> = {\n\trun(input: boolean) {\n\t\treturn input //\n\t\t\t? Result.err(new ExpectedConstraintError('s.boolean.false', 'Invalid boolean value', input, 'false'))\n\t\t\t: Result.ok(input);\n\t}\n};\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { booleanFalse, booleanTrue } from '../constraints/BooleanConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class BooleanValidator<T extends boolean = boolean> extends BaseValidator<T> {\n\tpublic get true(): BooleanValidator<true> {\n\t\treturn this.addConstraint(booleanTrue as IConstraint<T>) as BooleanValidator<true>;\n\t}\n\n\tpublic get false(): BooleanValidator<false> {\n\t\treturn this.addConstraint(booleanFalse as IConstraint<T>) as BooleanValidator<false>;\n\t}\n\n\tpublic equal<R extends true | false>(value: R): BooleanValidator<R> {\n\t\treturn (value ? this.true : this.false) as BooleanValidator<R>;\n\t}\n\n\tpublic notEqual<R extends true | false>(value: R): BooleanValidator<R> {\n\t\treturn (value ? this.false : this.true) as BooleanValidator<R>;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'boolean' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.boolean', 'Expected a boolean primitive', value));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type DateConstraintName = `s.date.${\n\t| 'lessThan'\n\t| 'lessThanOrEqual'\n\t| 'greaterThan'\n\t| 'greaterThanOrEqual'\n\t| 'equal'\n\t| 'notEqual'\n\t| 'valid'\n\t| 'invalid'}`;\n\nfunction dateComparator(comparator: Comparator, name: DateConstraintName, expected: string, number: number): IConstraint<Date> {\n\treturn {\n\t\trun(input: Date) {\n\t\t\treturn comparator(input.getTime(), number) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Date value', input, expected));\n\t\t}\n\t};\n}\n\nexport function dateLessThan(value: Date): IConstraint<Date> {\n\tconst expected = `expected < ${value.toISOString()}`;\n\treturn dateComparator(lessThan, 's.date.lessThan', expected, value.getTime());\n}\n\nexport function dateLessThanOrEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected <= ${value.toISOString()}`;\n\treturn dateComparator(lessThanOrEqual, 's.date.lessThanOrEqual', expected, value.getTime());\n}\n\nexport function dateGreaterThan(value: Date): IConstraint<Date> {\n\tconst expected = `expected > ${value.toISOString()}`;\n\treturn dateComparator(greaterThan, 's.date.greaterThan', expected, value.getTime());\n}\n\nexport function dateGreaterThanOrEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected >= ${value.toISOString()}`;\n\treturn dateComparator(greaterThanOrEqual, 's.date.greaterThanOrEqual', expected, value.getTime());\n}\n\nexport function dateEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected === ${value.toISOString()}`;\n\treturn dateComparator(equal, 's.date.equal', expected, value.getTime());\n}\n\nexport function dateNotEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected !== ${value.toISOString()}`;\n\treturn dateComparator(notEqual, 's.date.notEqual', expected, value.getTime());\n}\n\nexport const dateInvalid: IConstraint<Date> = {\n\trun(input: Date) {\n\t\treturn Number.isNaN(input.getTime()) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.date.invalid', 'Invalid Date value', input, 'expected === NaN'));\n\t}\n};\n\nexport const dateValid: IConstraint<Date> = {\n\trun(input: Date) {\n\t\treturn Number.isNaN(input.getTime()) //\n\t\t\t? Result.err(new ExpectedConstraintError('s.date.valid', 'Invalid Date value', input, 'expected !== NaN'))\n\t\t\t: Result.ok(input);\n\t}\n};\n","import {\n\tdateEqual,\n\tdateGreaterThan,\n\tdateGreaterThanOrEqual,\n\tdateInvalid,\n\tdateLessThan,\n\tdateLessThanOrEqual,\n\tdateNotEqual,\n\tdateValid\n} from '../constraints/DateConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class DateValidator extends BaseValidator<Date> {\n\tpublic lessThan(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateLessThan(new Date(date)));\n\t}\n\n\tpublic lessThanOrEqual(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateLessThanOrEqual(new Date(date)));\n\t}\n\n\tpublic greaterThan(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateGreaterThan(new Date(date)));\n\t}\n\n\tpublic greaterThanOrEqual(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateGreaterThanOrEqual(new Date(date)));\n\t}\n\n\tpublic equal(date: Date | number | string): this {\n\t\tconst resolved = new Date(date);\n\t\treturn Number.isNaN(resolved.getTime()) //\n\t\t\t? this.invalid\n\t\t\t: this.addConstraint(dateEqual(resolved));\n\t}\n\n\tpublic notEqual(date: Date | number | string): this {\n\t\tconst resolved = new Date(date);\n\t\treturn Number.isNaN(resolved.getTime()) //\n\t\t\t? this.valid\n\t\t\t: this.addConstraint(dateNotEqual(resolved));\n\t}\n\n\tpublic get valid(): this {\n\t\treturn this.addConstraint(dateValid);\n\t}\n\n\tpublic get invalid(): this {\n\t\treturn this.addConstraint(dateInvalid);\n\t}\n\n\tprotected handle(value: unknown): Result<Date, ValidationError> {\n\t\treturn value instanceof Date //\n\t\t\t? Result.ok(value)\n\t\t\t: Result.err(new ValidationError('s.date', 'Expected a Date', value));\n\t}\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { customInspectSymbolStackLess } from './BaseError';\nimport { ValidationError } from './ValidationError';\n\nexport class ExpectedValidationError<T> extends ValidationError {\n\tpublic readonly expected: T;\n\n\tpublic constructor(validator: string, message: string, given: unknown, expected: T) {\n\t\tsuper(validator, message, given);\n\t\tthis.expected = expected;\n\t}\n\n\tpublic override toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tvalidator: this.validator,\n\t\t\tgiven: this.given,\n\t\t\texpected: this.expected\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst validator = options.stylize(this.validator, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[ExpectedValidationError: ${validator}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1 };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst expected = inspect(this.expected, newOptions).replace(/\\n/g, padding);\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('ExpectedValidationError', 'special')} > ${validator}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst expectedBlock = `\\n ${options.stylize('Expected:', 'string')}${padding}${expected}`;\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${expectedBlock}\\n${givenBlock}`;\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { ExpectedValidationError } from '../lib/errors/ExpectedValidationError';\nimport { Result } from '../lib/Result';\nimport type { Constructor } from '../lib/util-types';\nimport { BaseValidator } from './imports';\n\nexport class InstanceValidator<T> extends BaseValidator<T> {\n\tpublic readonly expected: Constructor<T>;\n\n\tpublic constructor(expected: Constructor<T>, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.expected = expected;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ExpectedValidationError<Constructor<T>>> {\n\t\treturn value instanceof this.expected //\n\t\t\t? Result.ok(value)\n\t\t\t: Result.err(new ExpectedValidationError('s.instance(V)', 'Expected', value, this.expected));\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.expected, this.constraints]);\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { ExpectedValidationError } from '../lib/errors/ExpectedValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class LiteralValidator<T> extends BaseValidator<T> {\n\tpublic readonly expected: T;\n\n\tpublic constructor(literal: T, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.expected = literal;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ExpectedValidationError<T>> {\n\t\treturn Object.is(value, this.expected) //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ExpectedValidationError('s.literal(V)', 'Expected values to be equals', value, this.expected));\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.expected, this.constraints]);\n\t}\n}\n","import { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NeverValidator extends BaseValidator<never> {\n\tprotected handle(value: unknown): Result<never, ValidationError> {\n\t\treturn Result.err(new ValidationError('s.never', 'Expected a value to not be passed', value));\n\t}\n}\n","import { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NullishValidator extends BaseValidator<undefined | null> {\n\tprotected handle(value: unknown): Result<undefined | null, ValidationError> {\n\t\treturn value === undefined || value === null //\n\t\t\t? Result.ok(value)\n\t\t\t: Result.err(new ValidationError('s.nullish', 'Expected undefined or null', value));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type NumberConstraintName = `s.number.${\n\t| 'lessThan'\n\t| 'lessThanOrEqual'\n\t| 'greaterThan'\n\t| 'greaterThanOrEqual'\n\t| 'equal'\n\t| 'equal(NaN)'\n\t| 'notEqual'\n\t| 'notEqual(NaN)'\n\t| 'int'\n\t| 'safeInt'\n\t| 'finite'\n\t| 'divisibleBy'}`;\n\nfunction numberComparator(comparator: Comparator, name: NumberConstraintName, expected: string, number: number): IConstraint<number> {\n\treturn {\n\t\trun(input: number) {\n\t\t\treturn comparator(input, number) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid number value', input, expected));\n\t\t}\n\t};\n}\n\nexport function numberLessThan(value: number): IConstraint<number> {\n\tconst expected = `expected < ${value}`;\n\treturn numberComparator(lessThan, 's.number.lessThan', expected, value);\n}\n\nexport function numberLessThanOrEqual(value: number): IConstraint<number> {\n\tconst expected = `expected <= ${value}`;\n\treturn numberComparator(lessThanOrEqual, 's.number.lessThanOrEqual', expected, value);\n}\n\nexport function numberGreaterThan(value: number): IConstraint<number> {\n\tconst expected = `expected > ${value}`;\n\treturn numberComparator(greaterThan, 's.number.greaterThan', expected, value);\n}\n\nexport function numberGreaterThanOrEqual(value: number): IConstraint<number> {\n\tconst expected = `expected >= ${value}`;\n\treturn numberComparator(greaterThanOrEqual, 's.number.greaterThanOrEqual', expected, value);\n}\n\nexport function numberEqual(value: number): IConstraint<number> {\n\tconst expected = `expected === ${value}`;\n\treturn numberComparator(equal, 's.number.equal', expected, value);\n}\n\nexport function numberNotEqual(value: number): IConstraint<number> {\n\tconst expected = `expected !== ${value}`;\n\treturn numberComparator(notEqual, 's.number.notEqual', expected, value);\n}\n\nexport const numberInt: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isInteger(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(\n\t\t\t\t\tnew ExpectedConstraintError('s.number.int', 'Given value is not an integer', input, 'Number.isInteger(expected) to be true')\n\t\t\t );\n\t}\n};\n\nexport const numberSafeInt: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isSafeInteger(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(\n\t\t\t\t\tnew ExpectedConstraintError(\n\t\t\t\t\t\t's.number.safeInt',\n\t\t\t\t\t\t'Given value is not a safe integer',\n\t\t\t\t\t\tinput,\n\t\t\t\t\t\t'Number.isSafeInteger(expected) to be true'\n\t\t\t\t\t)\n\t\t\t );\n\t}\n};\n\nexport const numberFinite: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isFinite(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.number.finite', 'Given value is not finite', input, 'Number.isFinite(expected) to be true'));\n\t}\n};\n\nexport const numberNaN: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isNaN(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.number.equal(NaN)', 'Invalid number value', input, 'expected === NaN'));\n\t}\n};\n\nexport const numberNotNaN: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isNaN(input) //\n\t\t\t? Result.err(new ExpectedConstraintError('s.number.notEqual(NaN)', 'Invalid number value', input, 'expected !== NaN'))\n\t\t\t: Result.ok(input);\n\t}\n};\n\nexport function numberDivisibleBy(divider: number): IConstraint<number> {\n\tconst expected = `expected % ${divider} === 0`;\n\treturn {\n\t\trun(input: number) {\n\t\t\treturn input % divider === 0 //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.number.divisibleBy', 'Number is not divisible', input, expected));\n\t\t}\n\t};\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\tnumberDivisibleBy,\n\tnumberEqual,\n\tnumberFinite,\n\tnumberGreaterThan,\n\tnumberGreaterThanOrEqual,\n\tnumberInt,\n\tnumberLessThan,\n\tnumberLessThanOrEqual,\n\tnumberNaN,\n\tnumberNotEqual,\n\tnumberNotNaN,\n\tnumberSafeInt\n} from '../constraints/NumberConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NumberValidator<T extends number> extends BaseValidator<T> {\n\tpublic lessThan(number: number): this {\n\t\treturn this.addConstraint(numberLessThan(number) as IConstraint<T>);\n\t}\n\n\tpublic lessThanOrEqual(number: number): this {\n\t\treturn this.addConstraint(numberLessThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThan(number: number): this {\n\t\treturn this.addConstraint(numberGreaterThan(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThanOrEqual(number: number): this {\n\t\treturn this.addConstraint(numberGreaterThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic equal<N extends number>(number: N): NumberValidator<N> {\n\t\treturn Number.isNaN(number) //\n\t\t\t? (this.addConstraint(numberNaN as IConstraint<T>) as unknown as NumberValidator<N>)\n\t\t\t: (this.addConstraint(numberEqual(number) as IConstraint<T>) as unknown as NumberValidator<N>);\n\t}\n\n\tpublic notEqual(number: number): this {\n\t\treturn Number.isNaN(number) //\n\t\t\t? this.addConstraint(numberNotNaN as IConstraint<T>)\n\t\t\t: this.addConstraint(numberNotEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic get int(): this {\n\t\treturn this.addConstraint(numberInt as IConstraint<T>);\n\t}\n\n\tpublic get safeInt(): this {\n\t\treturn this.addConstraint(numberSafeInt as IConstraint<T>);\n\t}\n\n\tpublic get finite(): this {\n\t\treturn this.addConstraint(numberFinite as IConstraint<T>);\n\t}\n\n\tpublic get positive(): this {\n\t\treturn this.greaterThanOrEqual(0);\n\t}\n\n\tpublic get negative(): this {\n\t\treturn this.lessThan(0);\n\t}\n\n\tpublic divisibleBy(divider: number): this {\n\t\treturn this.addConstraint(numberDivisibleBy(divider) as IConstraint<T>);\n\t}\n\n\tpublic get abs(): this {\n\t\treturn this.transform(Math.abs as (value: number) => T);\n\t}\n\n\tpublic get sign(): this {\n\t\treturn this.transform(Math.sign as (value: number) => T);\n\t}\n\n\tpublic get trunc(): this {\n\t\treturn this.transform(Math.trunc as (value: number) => T);\n\t}\n\n\tpublic get floor(): this {\n\t\treturn this.transform(Math.floor as (value: number) => T);\n\t}\n\n\tpublic get fround(): this {\n\t\treturn this.transform(Math.fround as (value: number) => T);\n\t}\n\n\tpublic get round(): this {\n\t\treturn this.transform(Math.round as (value: number) => T);\n\t}\n\n\tpublic get ceil(): this {\n\t\treturn this.transform(Math.ceil as (value: number) => T);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'number' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.number', 'Expected a number primitive', value));\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class MissingPropertyError extends BaseError {\n\tpublic readonly property: PropertyKey;\n\n\tpublic constructor(property: PropertyKey) {\n\t\tsuper('A required property is missing');\n\t\tthis.property = property;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tproperty: this.property\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst property = options.stylize(this.property.toString(), 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[MissingPropertyError: ${property}]`, 'special');\n\t\t}\n\n\t\tconst header = `${options.stylize('MissingPropertyError', 'special')} > ${property}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\treturn `${header}\\n ${message}`;\n\t}\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class UnknownPropertyError extends BaseError {\n\tpublic readonly property: PropertyKey;\n\tpublic readonly value: unknown;\n\n\tpublic constructor(property: PropertyKey, value: unknown) {\n\t\tsuper('Received unexpected property');\n\n\t\tthis.property = property;\n\t\tthis.value = value;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tproperty: this.property,\n\t\t\tvalue: this.value\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst property = options.stylize(this.property.toString(), 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[UnknownPropertyError: ${property}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst given = inspect(this.value, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('UnknownPropertyError', 'special')} > ${property}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${givenBlock}`;\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { Result } from '../lib/Result';\nimport type { ValidatorError } from './BaseValidator';\nimport { BaseValidator } from './imports';\nimport { getValue } from './util/getValue';\n\nexport class DefaultValidator<T> extends BaseValidator<T> {\n\tprivate readonly validator: BaseValidator<T>;\n\tprivate defaultValue: T | (() => T);\n\n\tpublic constructor(validator: BaseValidator<T>, value: T | (() => T), constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t\tthis.defaultValue = value;\n\t}\n\n\tpublic override default(value: Exclude<T, undefined> | (() => Exclude<T, undefined>)): DefaultValidator<Exclude<T, undefined>> {\n\t\tconst clone = this.clone() as unknown as DefaultValidator<Exclude<T, undefined>>;\n\t\tclone.defaultValue = value;\n\t\treturn clone;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidatorError> {\n\t\treturn typeof value === 'undefined' //\n\t\t\t? Result.ok(getValue(this.defaultValue))\n\t\t\t: this.validator['handle'](value); // eslint-disable-line @typescript-eslint/dot-notation\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.defaultValue, this.constraints]);\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class CombinedError extends BaseError {\n\tpublic readonly errors: readonly BaseError[];\n\n\tpublic constructor(errors: readonly BaseError[]) {\n\t\tsuper('Received one or more errors');\n\n\t\tthis.errors = errors;\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize('[CombinedError]', 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\n\t\tconst header = `${options.stylize('CombinedError', 'special')} (${options.stylize(this.errors.length.toString(), 'number')})`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst errors = this.errors\n\t\t\t.map((error, i) => {\n\t\t\t\tconst index = options.stylize((i + 1).toString(), 'number');\n\t\t\t\tconst body = error[customInspectSymbolStackLess](depth - 1, newOptions).replace(/\\n/g, padding);\n\n\t\t\t\treturn ` ${index} ${body}`;\n\t\t\t})\n\t\t\t.join('\\n\\n');\n\t\treturn `${header}\\n ${message}\\n\\n${errors}`;\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedError } from '../lib/errors/CombinedError';\nimport type { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator, LiteralValidator, NullishValidator } from './imports';\n\nexport class UnionValidator<T> extends BaseValidator<T> {\n\tprivate validators: readonly BaseValidator<T>[];\n\n\tpublic constructor(validators: readonly BaseValidator<T>[], constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validators = validators;\n\t}\n\n\tpublic override get optional(): UnionValidator<T | undefined> {\n\t\tif (this.validators.length === 0) return new UnionValidator<T | undefined>([new LiteralValidator(undefined)], this.constraints);\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\t// If already optional, return a clone:\n\t\t\tif (validator.expected === undefined) return this.clone();\n\n\t\t\t// If it's nullable, convert the nullable validator into a nullish validator to optimize `null | undefined`:\n\t\t\tif (validator.expected === null) {\n\t\t\t\treturn new UnionValidator<T | null | undefined>(\n\t\t\t\t\t[new NullishValidator(), ...this.validators.slice(1)],\n\t\t\t\t\tthis.constraints\n\t\t\t\t) as UnionValidator<T | undefined>;\n\t\t\t}\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t// If it's already nullish (which validates optional), return a clone:\n\t\t\treturn this.clone();\n\t\t}\n\n\t\treturn new UnionValidator([new LiteralValidator(undefined), ...this.validators]);\n\t}\n\n\tpublic get required(): UnionValidator<Exclude<T, undefined>> {\n\t\ttype RequiredValidator = UnionValidator<Exclude<T, undefined>>;\n\n\t\tif (this.validators.length === 0) return this.clone() as unknown as RequiredValidator;\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\tif (validator.expected === undefined) return new UnionValidator(this.validators.slice(1), this.constraints) as RequiredValidator;\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\treturn new UnionValidator([new LiteralValidator(null), ...this.validators.slice(1)], this.constraints) as RequiredValidator;\n\t\t}\n\n\t\treturn this.clone() as unknown as RequiredValidator;\n\t}\n\n\tpublic override get nullable(): UnionValidator<T | null> {\n\t\tif (this.validators.length === 0) return new UnionValidator<T | null>([new LiteralValidator(null)], this.constraints);\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\t// If already nullable, return a clone:\n\t\t\tif (validator.expected === null) return this.clone();\n\n\t\t\t// If it's optional, convert the optional validator into a nullish validator to optimize `null | undefined`:\n\t\t\tif (validator.expected === undefined) {\n\t\t\t\treturn new UnionValidator<T | null | undefined>(\n\t\t\t\t\t[new NullishValidator(), ...this.validators.slice(1)],\n\t\t\t\t\tthis.constraints\n\t\t\t\t) as UnionValidator<T | null>;\n\t\t\t}\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t// If it's already nullish (which validates nullable), return a clone:\n\t\t\treturn this.clone();\n\t\t}\n\n\t\treturn new UnionValidator([new LiteralValidator(null), ...this.validators]);\n\t}\n\n\tpublic override get nullish(): UnionValidator<T | null | undefined> {\n\t\tif (this.validators.length === 0) return new UnionValidator<T | null | undefined>([new NullishValidator()], this.constraints);\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\t// If already nullable or optional, promote the union to nullish:\n\t\t\tif (validator.expected === null || validator.expected === undefined) {\n\t\t\t\treturn new UnionValidator<T | null | undefined>([new NullishValidator(), ...this.validators.slice(1)], this.constraints);\n\t\t\t}\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t// If it's already nullish, return a clone:\n\t\t\treturn this.clone();\n\t\t}\n\n\t\treturn new UnionValidator<T | null | undefined>([new NullishValidator(), ...this.validators]);\n\t}\n\n\tpublic override or<O>(...predicates: readonly BaseValidator<O>[]): UnionValidator<T | O> {\n\t\treturn new UnionValidator<T | O>([...this.validators, ...predicates]);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validators, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError | CombinedError> {\n\t\tconst errors: BaseError[] = [];\n\n\t\tfor (const validator of this.validators) {\n\t\t\tconst result = validator.run(value);\n\t\t\tif (result.isOk()) return result as Result<T, CombinedError>;\n\t\t\terrors.push(result.error!);\n\t\t}\n\n\t\treturn Result.err(new CombinedError(errors));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { MissingPropertyError } from '../lib/errors/MissingPropertyError';\nimport { UnknownPropertyError } from '../lib/errors/UnknownPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport type { MappedObjectValidator, UndefinedToOptional } from '../lib/util-types';\nimport { BaseValidator } from './BaseValidator';\nimport { DefaultValidator } from './DefaultValidator';\nimport { LiteralValidator } from './LiteralValidator';\nimport { NullishValidator } from './NullishValidator';\nimport { UnionValidator } from './UnionValidator';\n\nexport class ObjectValidator<T extends object, I = UndefinedToOptional<T>> extends BaseValidator<I> {\n\tpublic readonly shape: MappedObjectValidator<T>;\n\tpublic readonly strategy: ObjectValidatorStrategy;\n\tprivate readonly keys: readonly (keyof I)[] = [];\n\tprivate readonly handleStrategy: (value: object) => Result<I, CombinedPropertyError>;\n\n\tprivate readonly requiredKeys = new Map<keyof I, BaseValidator<unknown>>();\n\tprivate readonly possiblyUndefinedKeys = new Map<keyof I, BaseValidator<unknown>>();\n\tprivate readonly possiblyUndefinedKeysWithDefaults = new Map<keyof I, DefaultValidator<unknown>>();\n\n\tpublic constructor(\n\t\tshape: MappedObjectValidator<T>,\n\t\tstrategy: ObjectValidatorStrategy = ObjectValidatorStrategy.Ignore,\n\t\tconstraints: readonly IConstraint<I>[] = []\n\t) {\n\t\tsuper(constraints);\n\t\tthis.shape = shape;\n\t\tthis.strategy = strategy;\n\n\t\tswitch (this.strategy) {\n\t\t\tcase ObjectValidatorStrategy.Ignore:\n\t\t\t\tthis.handleStrategy = (value) => this.handleIgnoreStrategy(value);\n\t\t\t\tbreak;\n\t\t\tcase ObjectValidatorStrategy.Strict: {\n\t\t\t\tthis.handleStrategy = (value) => this.handleStrictStrategy(value);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase ObjectValidatorStrategy.Passthrough:\n\t\t\t\tthis.handleStrategy = (value) => this.handlePassthroughStrategy(value);\n\t\t\t\tbreak;\n\t\t}\n\n\t\tconst shapeEntries = Object.entries(shape) as [keyof I, BaseValidator<T>][];\n\t\tthis.keys = shapeEntries.map(([key]) => key);\n\n\t\tfor (const [key, validator] of shapeEntries) {\n\t\t\tif (validator instanceof UnionValidator) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/dot-notation\n\t\t\t\tconst [possiblyLiteralOrNullishPredicate] = validator['validators'];\n\n\t\t\t\tif (possiblyLiteralOrNullishPredicate instanceof NullishValidator) {\n\t\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t\t} else if (possiblyLiteralOrNullishPredicate instanceof LiteralValidator) {\n\t\t\t\t\tif (possiblyLiteralOrNullishPredicate.expected === undefined) {\n\t\t\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t\t\t}\n\t\t\t\t} else if (validator instanceof DefaultValidator) {\n\t\t\t\t\tthis.possiblyUndefinedKeysWithDefaults.set(key, validator);\n\t\t\t\t} else {\n\t\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t\t}\n\t\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t} else if (validator instanceof LiteralValidator) {\n\t\t\t\tif (validator.expected === undefined) {\n\t\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t\t} else {\n\t\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t\t}\n\t\t\t} else if (validator instanceof DefaultValidator) {\n\t\t\t\tthis.possiblyUndefinedKeysWithDefaults.set(key, validator);\n\t\t\t} else {\n\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic get strict(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, ObjectValidatorStrategy.Strict, this.constraints]);\n\t}\n\n\tpublic get ignore(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, ObjectValidatorStrategy.Ignore, this.constraints]);\n\t}\n\n\tpublic get passthrough(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, ObjectValidatorStrategy.Passthrough, this.constraints]);\n\t}\n\n\tpublic get partial(): ObjectValidator<{ [Key in keyof I]?: I[Key] }> {\n\t\tconst shape = Object.fromEntries(this.keys.map((key) => [key, this.shape[key as unknown as keyof typeof this.shape].optional]));\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic get required(): ObjectValidator<{ [Key in keyof I]-?: I[Key] }> {\n\t\tconst shape = Object.fromEntries(\n\t\t\tthis.keys.map((key) => {\n\t\t\t\tlet validator = this.shape[key as unknown as keyof typeof this.shape];\n\t\t\t\tif (validator instanceof UnionValidator) validator = validator.required;\n\t\t\t\treturn [key, validator];\n\t\t\t})\n\t\t);\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic extend<ET extends object>(schema: ObjectValidator<ET> | MappedObjectValidator<ET>): ObjectValidator<T & ET> {\n\t\tconst shape = { ...this.shape, ...(schema instanceof ObjectValidator ? schema.shape : schema) };\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic pick<K extends keyof I>(keys: readonly K[]): ObjectValidator<{ [Key in keyof Pick<I, K>]: I[Key] }> {\n\t\tconst shape = Object.fromEntries(\n\t\t\tkeys.filter((key) => this.keys.includes(key)).map((key) => [key, this.shape[key as unknown as keyof typeof this.shape]])\n\t\t);\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic omit<K extends keyof I>(keys: readonly K[]): ObjectValidator<{ [Key in keyof Omit<I, K>]: I[Key] }> {\n\t\tconst shape = Object.fromEntries(\n\t\t\tthis.keys.filter((key) => !keys.includes(key as any)).map((key) => [key, this.shape[key as unknown as keyof typeof this.shape]])\n\t\t);\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tprotected override handle(value: unknown): Result<I, ValidationError | CombinedPropertyError> {\n\t\tconst typeOfValue = typeof value;\n\t\tif (typeOfValue !== 'object') {\n\t\t\treturn Result.err(new ValidationError('s.object(T)', `Expected the value to be an object, but received ${typeOfValue} instead`, value));\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn Result.err(new ValidationError('s.object(T)', 'Expected the value to not be null', value));\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\treturn Result.err(new ValidationError('s.object(T)', 'Expected the value to not be an array', value));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(value as I);\n\t\t}\n\n\t\tfor (const predicate of Object.values(this.shape) as BaseValidator<any>[]) {\n\t\t\tpredicate.setParent(this.parent ?? value!);\n\t\t}\n\n\t\treturn this.handleStrategy(value as object);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, this.strategy, this.constraints]);\n\t}\n\n\tprivate handleIgnoreStrategy(value: object): Result<I, CombinedPropertyError> {\n\t\tconst errors: [PropertyKey, BaseError][] = [];\n\t\tconst finalObject = {} as I;\n\t\tconst inputEntries = new Map(Object.entries(value) as [keyof I, unknown][]);\n\n\t\tconst runPredicate = (key: keyof I, predicate: BaseValidator<unknown>) => {\n\t\t\tconst result = predicate.run(value[key as keyof object]);\n\n\t\t\tif (result.isOk()) {\n\t\t\t\tfinalObject[key] = result.value as I[keyof I];\n\t\t\t} else {\n\t\t\t\tconst error = result.error!;\n\t\t\t\terrors.push([key, error]);\n\t\t\t}\n\t\t};\n\n\t\tfor (const [key, predicate] of this.requiredKeys) {\n\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\trunPredicate(key, predicate);\n\t\t\t} else {\n\t\t\t\terrors.push([key, new MissingPropertyError(key)]);\n\t\t\t}\n\t\t}\n\n\t\t// Run possibly undefined keys that also have defaults even if there are no more keys to process (this is necessary so we fill in those defaults)\n\t\tfor (const [key, validator] of this.possiblyUndefinedKeysWithDefaults) {\n\t\t\tinputEntries.delete(key);\n\t\t\trunPredicate(key, validator);\n\t\t}\n\n\t\t// Early exit if there are no more properties to validate in the object and there are errors to report\n\t\tif (inputEntries.size === 0) {\n\t\t\treturn errors.length === 0 //\n\t\t\t\t? Result.ok(finalObject)\n\t\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t\t}\n\n\t\t// In the event the remaining keys to check are less than the number of possible undefined keys, we check those\n\t\t// as it could yield a faster execution\n\t\tconst checkInputEntriesInsteadOfSchemaKeys = this.possiblyUndefinedKeys.size > inputEntries.size;\n\n\t\tif (checkInputEntriesInsteadOfSchemaKeys) {\n\t\t\tfor (const [key] of inputEntries) {\n\t\t\t\tconst predicate = this.possiblyUndefinedKeys.get(key);\n\n\t\t\t\tif (predicate) {\n\t\t\t\t\trunPredicate(key, predicate);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor (const [key, predicate] of this.possiblyUndefinedKeys) {\n\t\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\t\trunPredicate(key, predicate);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(finalObject)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n\n\tprivate handleStrictStrategy(value: object): Result<I, CombinedPropertyError> {\n\t\tconst errors: [PropertyKey, BaseError][] = [];\n\t\tconst finalResult = {} as I;\n\t\tconst inputEntries = new Map(Object.entries(value) as [keyof I, unknown][]);\n\n\t\tconst runPredicate = (key: keyof I, predicate: BaseValidator<unknown>) => {\n\t\t\tconst result = predicate.run(value[key as keyof object]);\n\n\t\t\tif (result.isOk()) {\n\t\t\t\tfinalResult[key] = result.value as I[keyof I];\n\t\t\t} else {\n\t\t\t\tconst error = result.error!;\n\t\t\t\terrors.push([key, error]);\n\t\t\t}\n\t\t};\n\n\t\tfor (const [key, predicate] of this.requiredKeys) {\n\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\trunPredicate(key, predicate);\n\t\t\t} else {\n\t\t\t\terrors.push([key, new MissingPropertyError(key)]);\n\t\t\t}\n\t\t}\n\n\t\t// Run possibly undefined keys that also have defaults even if there are no more keys to process (this is necessary so we fill in those defaults)\n\t\tfor (const [key, validator] of this.possiblyUndefinedKeysWithDefaults) {\n\t\t\tinputEntries.delete(key);\n\t\t\trunPredicate(key, validator);\n\t\t}\n\n\t\tfor (const [key, predicate] of this.possiblyUndefinedKeys) {\n\t\t\t// All of these validators are assumed to be possibly undefined, so if we have gone through the entire object and there's still validators,\n\t\t\t// safe to assume we're done here\n\t\t\tif (inputEntries.size === 0) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\trunPredicate(key, predicate);\n\t\t\t}\n\t\t}\n\n\t\tif (inputEntries.size !== 0) {\n\t\t\tfor (const [key, value] of inputEntries.entries()) {\n\t\t\t\terrors.push([key, new UnknownPropertyError(key, value)]);\n\t\t\t}\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(finalResult)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n\n\tprivate handlePassthroughStrategy(value: object): Result<I, CombinedPropertyError> {\n\t\tconst result = this.handleIgnoreStrategy(value);\n\t\treturn result.isErr() ? result : Result.ok({ ...value, ...result.value } as I);\n\t}\n}\n\nexport enum ObjectValidatorStrategy {\n\tIgnore,\n\tStrict,\n\tPassthrough\n}\n","import type { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class PassthroughValidator<T extends any | unknown> extends BaseValidator<T> {\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn Result.ok(value as T);\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class RecordValidator<T> extends BaseValidator<Record<string, T>> {\n\tprivate readonly validator: BaseValidator<T>;\n\n\tpublic constructor(validator: BaseValidator<T>, constraints: readonly IConstraint<Record<string, T>>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<Record<string, T>, ValidationError | CombinedPropertyError> {\n\t\tif (typeof value !== 'object') {\n\t\t\treturn Result.err(new ValidationError('s.record(T)', 'Expected an object', value));\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn Result.err(new ValidationError('s.record(T)', 'Expected the value to not be null', value));\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\treturn Result.err(new ValidationError('s.record(T)', 'Expected the value to not be an array', value));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(value as Record<string, T>);\n\t\t}\n\n\t\tconst errors: [string, BaseError][] = [];\n\t\tconst transformed: Record<string, T> = {};\n\n\t\tfor (const [key, val] of Object.entries(value!)) {\n\t\t\tconst result = this.validator.run(val);\n\t\t\tif (result.isOk()) transformed[key] = result.value;\n\t\t\telse errors.push([key, result.error!]);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedError } from '../lib/errors/CombinedError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class SetValidator<T> extends BaseValidator<Set<T>> {\n\tprivate readonly validator: BaseValidator<T>;\n\n\tpublic constructor(validator: BaseValidator<T>, constraints: readonly IConstraint<Set<T>>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<Set<T>, ValidationError | CombinedError> {\n\t\tif (!(values instanceof Set)) {\n\t\t\treturn Result.err(new ValidationError('s.set(T)', 'Expected a set', values));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(values);\n\t\t}\n\n\t\tconst errors: BaseError[] = [];\n\t\tconst transformed = new Set<T>();\n\n\t\tfor (const value of values) {\n\t\t\tconst result = this.validator.run(value);\n\t\t\tif (result.isOk()) transformed.add(result.value);\n\t\t\telse errors.push(result.error!);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedError(errors));\n\t}\n}\n","/**\n * [RFC-5322](https://datatracker.ietf.org/doc/html/rfc5322)\n * compliant {@link RegExp} to validate an email address\n *\n * @see https://stackoverflow.com/questions/201323/how-can-i-validate-an-email-address-using-a-regular-expression/201378#201378\n */\nconst accountRegex =\n\t/^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")$/;\n\n/**\n * Validates an email address string based on various checks:\n * - It must be a non nullish and non empty string\n * - It must include at least an `@` symbol`\n * - The account name may not exceed 64 characters\n * - The domain name may not exceed 255 characters\n * - The domain must include at least one `.` symbol\n * - Each part of the domain, split by `.` must not exceed 63 characters\n * - The email address must be [RFC-5322](https://datatracker.ietf.org/doc/html/rfc5322) compliant\n * @param email The email to validate\n * @returns `true` if the email is valid, `false` otherwise\n *\n * @remark Based on the following sources:\n * - `email-validator` by [manisharaan](https://github.com/manishsaraan) ([code](https://github.com/manishsaraan/email-validator/blob/master/index.js))\n * - [Comparing E-mail Address Validating Regular Expressions](http://fightingforalostcause.net/misc/2006/compare-email-regex.php)\n * - [Validating Email Addresses by Derrick Pallas](http://thedailywtf.com/Articles/Validating_Email_Addresses.aspx)\n * - [StackOverflow answer by bortzmeyer](http://stackoverflow.com/questions/201323/what-is-the-best-regular-expression-for-validating-email-addresses/201378#201378)\n * - [The wikipedia page on Email addresses](https://en.wikipedia.org/wiki/Email_address)\n */\nexport function validateEmail(email: string): boolean {\n\t// 1. Non-nullish and non-empty string check.\n\t//\n\t// If a nullish or empty email was provided then do an early exit\n\tif (!email) return false;\n\n\t// Find the location of the @ symbol:\n\tconst atIndex = email.indexOf('@');\n\n\t// 2. @ presence check.\n\t//\n\t// If the email does not have the @ symbol, it's automatically invalid:\n\tif (atIndex === -1) return false;\n\n\t// 3. <account> maximum length check.\n\t//\n\t// From <account>@<domain>, if <account> exceeds 64 characters, then the\n\t// position of the @ symbol is 64 or greater. In this case, the email is\n\t// invalid:\n\tif (atIndex > 64) return false;\n\n\tconst domainIndex = atIndex + 1;\n\n\t// 7.1. Duplicated @ symbol check.\n\t//\n\t// If there's a second @ symbol, the email is automatically invalid:\n\tif (email.includes('@', domainIndex)) return false;\n\n\t// 4. <domain> maximum length check.\n\t//\n\t// From <account>@<domain>, if <domain> exceeds 255 characters, then it\n\t// means that the amount of characters between the start of <domain> and the\n\t// end of the string is separated by 255 or more characters.\n\tif (email.length - domainIndex > 255) return false;\n\n\t// Find the location of the . symbol in <domain>:\n\tlet dotIndex = email.indexOf('.', domainIndex);\n\n\t// 5. <domain> dot (.) symbol check.\n\t//\n\t// From <account>@<domain>, if <domain> does not contain a dot (.) symbol,\n\t// then it means the domain is invalid.\n\tif (dotIndex === -1) return false;\n\n\t// 6. <domain> parts length.\n\t//\n\t// Assign a temporary variable to store the start of the last read domain\n\t// part, this would be at the start of <domain>.\n\t//\n\t// For a <domain> part to be correct, it must have at most, 63 characters.\n\t// We repeat this step for every sub-section of <domain> contained within\n\t// dot (.) symbols.\n\t//\n\t// The following step is a more optimized version of the following code:\n\t//\n\t// ```javascript\n\t// domain.split('.').some((part) => part.length > 63);\n\t// ```\n\tlet lastDotIndex = domainIndex;\n\tdo {\n\t\tif (dotIndex - lastDotIndex > 63) return false;\n\n\t\tlastDotIndex = dotIndex + 1;\n\t} while ((dotIndex = email.indexOf('.', lastDotIndex)) !== -1);\n\n\t// The loop iterates from the first to the n - 1 part, this line checks for\n\t// the last (n) part:\n\tif (email.length - lastDotIndex > 63) return false;\n\n\t// 7.2. Character checks.\n\t//\n\t// From <account>@<domain>:\n\t// - Extract the <account> part by slicing the input from start to the @\n\t// character. Validate afterwards.\n\t// - Extract the <domain> part by slicing the input from the start of\n\t// <domain>. Validate afterwards.\n\t//\n\t// Note: we inline the variables so <domain> isn't created unless the\n\t// <account> check passes.\n\treturn accountRegex.test(email.slice(0, atIndex)) && validateEmailDomain(email.slice(domainIndex));\n}\n\nfunction validateEmailDomain(domain: string): boolean {\n\ttry {\n\t\treturn new URL(`http://${domain}`).hostname === domain;\n\t} catch {\n\t\treturn false;\n\t}\n}\n","/**\n * Code ported from https://github.com/nodejs/node/blob/5fad0b93667ffc6e4def52996b9529ac99b26319/lib/internal/net.js\n */\n\n// IPv4 Segment\nconst v4Seg = '(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])';\nconst v4Str = `(${v4Seg}[.]){3}${v4Seg}`;\nconst IPv4Reg = new RegExp(`^${v4Str}$`);\n\n// IPv6 Segment\nconst v6Seg = '(?:[0-9a-fA-F]{1,4})';\nconst IPv6Reg = new RegExp(\n\t'^(' +\n\t\t`(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +\n\t\t`(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +\n\t\t`(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` +\n\t\t`(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` +\n\t\t`(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` +\n\t\t`(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` +\n\t\t`(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` +\n\t\t`(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +\n\t\t')(%[0-9a-zA-Z-.:]{1,})?$'\n);\n\nexport function isIPv4(s: string): boolean {\n\treturn IPv4Reg.test(s);\n}\n\nexport function isIPv6(s: string): boolean {\n\treturn IPv6Reg.test(s);\n}\n\nexport function isIP(s: string): number {\n\tif (isIPv4(s)) return 4;\n\tif (isIPv6(s)) return 6;\n\treturn 0;\n}\n","export const phoneNumberRegex = /^((?:\\+|0{0,2})\\d{1,2}\\s?)?\\(?\\d{3}\\)?[\\s.-]?\\d{3}[\\s.-]?\\d{4}$/;\n\nexport function validatePhoneNumber(input: string) {\n\treturn phoneNumberRegex.test(input);\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { customInspectSymbolStackLess } from './BaseError';\nimport { BaseConstraintError, type ConstraintErrorNames } from './BaseConstraintError';\n\nexport class MultiplePossibilitiesConstraintError<T = unknown> extends BaseConstraintError<T> {\n\tpublic readonly expected: readonly string[];\n\n\tpublic constructor(constraint: ConstraintErrorNames, message: string, given: T, expected: readonly string[]) {\n\t\tsuper(constraint, message, given);\n\t\tthis.expected = expected;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tconstraint: this.constraint,\n\t\t\tgiven: this.given,\n\t\t\texpected: this.expected\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst constraint = options.stylize(this.constraint, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[MultiplePossibilitiesConstraintError: ${constraint}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1 };\n\n\t\tconst verticalLine = options.stylize('|', 'undefined');\n\t\tconst padding = `\\n ${verticalLine} `;\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('MultiplePossibilitiesConstraintError', 'special')} > ${constraint}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\n\t\tconst expectedPadding = `\\n ${verticalLine} - `;\n\t\tconst expectedBlock = `\\n ${options.stylize('Expected any of the following:', 'string')}${expectedPadding}${this.expected\n\t\t\t.map((possible) => options.stylize(possible, 'boolean'))\n\t\t\t.join(expectedPadding)}`;\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${expectedBlock}\\n${givenBlock}`;\n\t}\n}\n","export function combinedErrorFn<P extends [...any], E extends Error>(...fns: ErrorFn<P, E>[]): ErrorFn<P, E> {\n\tswitch (fns.length) {\n\t\tcase 0:\n\t\t\treturn () => null;\n\t\tcase 1:\n\t\t\treturn fns[0];\n\t\tcase 2: {\n\t\t\tconst [fn0, fn1] = fns;\n\t\t\treturn (...params) => fn0(...params) || fn1(...params);\n\t\t}\n\t\tdefault: {\n\t\t\treturn (...params) => {\n\t\t\t\tfor (const fn of fns) {\n\t\t\t\t\tconst result = fn(...params);\n\t\t\t\t\tif (result) return result;\n\t\t\t\t}\n\n\t\t\t\treturn null;\n\t\t\t};\n\t\t}\n\t}\n}\n\nexport type ErrorFn<P extends [...any], E extends Error> = (...params: P) => E | null;\n","import { MultiplePossibilitiesConstraintError } from '../../lib/errors/MultiplePossibilitiesConstraintError';\nimport { combinedErrorFn, type ErrorFn } from './common/combinedResultFn';\n\nexport type StringProtocol = `${string}:`;\n\nexport type StringDomain = `${string}.${string}`;\n\nexport interface UrlOptions {\n\tallowedProtocols?: StringProtocol[];\n\tallowedDomains?: StringDomain[];\n}\n\nexport function createUrlValidators(options?: UrlOptions) {\n\tconst fns: ErrorFn<[input: string, url: URL], MultiplePossibilitiesConstraintError<string>>[] = [];\n\n\tif (options?.allowedProtocols?.length) fns.push(allowedProtocolsFn(options.allowedProtocols));\n\tif (options?.allowedDomains?.length) fns.push(allowedDomainsFn(options.allowedDomains));\n\n\treturn combinedErrorFn(...fns);\n}\n\nfunction allowedProtocolsFn(allowedProtocols: StringProtocol[]) {\n\treturn (input: string, url: URL) =>\n\t\tallowedProtocols.includes(url.protocol as StringProtocol)\n\t\t\t? null\n\t\t\t: new MultiplePossibilitiesConstraintError('s.string.url', 'Invalid URL protocol', input, allowedProtocols);\n}\n\nfunction allowedDomainsFn(allowedDomains: StringDomain[]) {\n\treturn (input: string, url: URL) =>\n\t\tallowedDomains.includes(url.hostname as StringDomain)\n\t\t\t? null\n\t\t\t: new MultiplePossibilitiesConstraintError('s.string.url', 'Invalid URL domain', input, allowedDomains);\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { validateEmail } from './util/emailValidator';\nimport { isIP, isIPv4, isIPv6 } from './util/net';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\nimport { validatePhoneNumber } from './util/phoneValidator';\nimport { createUrlValidators } from './util/urlValidators';\n\nexport type StringConstraintName =\n\t| `s.string.${\n\t\t\t| `length${'LessThan' | 'LessThanOrEqual' | 'GreaterThan' | 'GreaterThanOrEqual' | 'Equal' | 'NotEqual'}`\n\t\t\t| 'regex'\n\t\t\t| 'url'\n\t\t\t| 'uuid'\n\t\t\t| 'email'\n\t\t\t| `ip${'v4' | 'v6' | ''}`\n\t\t\t| 'date'\n\t\t\t| 'phone'}`;\n\nexport type StringProtocol = `${string}:`;\n\nexport type StringDomain = `${string}.${string}`;\n\nexport interface UrlOptions {\n\tallowedProtocols?: StringProtocol[];\n\tallowedDomains?: StringDomain[];\n}\n\nexport type UUIDVersion = 1 | 3 | 4 | 5;\n\nexport interface StringUuidOptions {\n\tversion?: UUIDVersion | `${UUIDVersion}-${UUIDVersion}` | null;\n\tnullable?: boolean;\n}\n\nfunction stringLengthComparator(comparator: Comparator, name: StringConstraintName, expected: string, length: number): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn comparator(input.length, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid string length', input, expected));\n\t\t}\n\t};\n}\n\nexport function stringLengthLessThan(length: number): IConstraint<string> {\n\tconst expected = `expected.length < ${length}`;\n\treturn stringLengthComparator(lessThan, 's.string.lengthLessThan', expected, length);\n}\n\nexport function stringLengthLessThanOrEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length <= ${length}`;\n\treturn stringLengthComparator(lessThanOrEqual, 's.string.lengthLessThanOrEqual', expected, length);\n}\n\nexport function stringLengthGreaterThan(length: number): IConstraint<string> {\n\tconst expected = `expected.length > ${length}`;\n\treturn stringLengthComparator(greaterThan, 's.string.lengthGreaterThan', expected, length);\n}\n\nexport function stringLengthGreaterThanOrEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length >= ${length}`;\n\treturn stringLengthComparator(greaterThanOrEqual, 's.string.lengthGreaterThanOrEqual', expected, length);\n}\n\nexport function stringLengthEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length === ${length}`;\n\treturn stringLengthComparator(equal, 's.string.lengthEqual', expected, length);\n}\n\nexport function stringLengthNotEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length !== ${length}`;\n\treturn stringLengthComparator(notEqual, 's.string.lengthNotEqual', expected, length);\n}\n\nexport function stringEmail(): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn validateEmail(input)\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.string.email', 'Invalid email address', input, 'expected to be an email address'));\n\t\t}\n\t};\n}\n\nfunction stringRegexValidator(type: StringConstraintName, expected: string, regex: RegExp): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn regex.test(input) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(type, 'Invalid string format', input, expected));\n\t\t}\n\t};\n}\n\nexport function stringUrl(options?: UrlOptions): IConstraint<string> {\n\tconst validatorFn = createUrlValidators(options);\n\treturn {\n\t\trun(input: string) {\n\t\t\tlet url: URL;\n\t\t\ttry {\n\t\t\t\turl = new URL(input);\n\t\t\t} catch {\n\t\t\t\treturn Result.err(new ExpectedConstraintError('s.string.url', 'Invalid URL', input, 'expected to match a URL'));\n\t\t\t}\n\n\t\t\tconst validatorFnResult = validatorFn(input, url);\n\t\t\tif (validatorFnResult === null) return Result.ok(input);\n\t\t\treturn Result.err(validatorFnResult);\n\t\t}\n\t};\n}\n\nexport function stringIp(version?: 4 | 6): IConstraint<string> {\n\tconst ipVersion = version ? (`v${version}` as const) : '';\n\tconst validatorFn = version === 4 ? isIPv4 : version === 6 ? isIPv6 : isIP;\n\n\tconst name = `s.string.ip${ipVersion}` as const;\n\tconst message = `Invalid IP${ipVersion} address`;\n\tconst expected = `expected to be an IP${ipVersion} address`;\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn validatorFn(input) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, message, input, expected));\n\t\t}\n\t};\n}\n\nexport function stringRegex(regex: RegExp) {\n\treturn stringRegexValidator('s.string.regex', `expected ${regex}.test(expected) to be true`, regex);\n}\n\nexport function stringUuid({ version = 4, nullable = false }: StringUuidOptions = {}) {\n\tversion ??= '1-5';\n\tconst regex = new RegExp(\n\t\t`^(?:[0-9A-F]{8}-[0-9A-F]{4}-[${version}][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}${\n\t\t\tnullable ? '|00000000-0000-0000-0000-000000000000' : ''\n\t\t})$`,\n\t\t'i'\n\t);\n\tconst expected = `expected to match UUID${typeof version === 'number' ? `v${version}` : ` in range of ${version}`}`;\n\treturn stringRegexValidator('s.string.uuid', expected, regex);\n}\n\nexport function stringDate(): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\tconst time = Date.parse(input);\n\n\t\t\treturn Number.isNaN(time)\n\t\t\t\t? Result.err(\n\t\t\t\t\t\tnew ExpectedConstraintError(\n\t\t\t\t\t\t\t's.string.date',\n\t\t\t\t\t\t\t'Invalid date string',\n\t\t\t\t\t\t\tinput,\n\t\t\t\t\t\t\t'expected to be a valid date string (in the ISO 8601 or ECMA-262 format)'\n\t\t\t\t\t\t)\n\t\t\t\t )\n\t\t\t\t: Result.ok(input);\n\t\t}\n\t};\n}\n\nexport function stringPhone(): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn validatePhoneNumber(input)\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.string.phone', 'Invalid phone number', input, 'expected to be a phone number'));\n\t\t}\n\t};\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\tstringDate,\n\tstringEmail,\n\tstringIp,\n\tstringLengthEqual,\n\tstringLengthGreaterThan,\n\tstringLengthGreaterThanOrEqual,\n\tstringLengthLessThan,\n\tstringLengthLessThanOrEqual,\n\tstringLengthNotEqual,\n\tstringPhone,\n\tstringRegex,\n\tstringUrl,\n\tstringUuid,\n\ttype StringUuidOptions,\n\ttype UrlOptions\n} from '../constraints/StringConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class StringValidator<T extends string> extends BaseValidator<T> {\n\tpublic lengthLessThan(length: number): this {\n\t\treturn this.addConstraint(stringLengthLessThan(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthLessThanOrEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthLessThanOrEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthGreaterThan(length: number): this {\n\t\treturn this.addConstraint(stringLengthGreaterThan(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthGreaterThanOrEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthGreaterThanOrEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthNotEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthNotEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic get email(): this {\n\t\treturn this.addConstraint(stringEmail() as IConstraint<T>);\n\t}\n\n\tpublic url(options?: UrlOptions): this {\n\t\treturn this.addConstraint(stringUrl(options) as IConstraint<T>);\n\t}\n\n\tpublic uuid(options?: StringUuidOptions): this {\n\t\treturn this.addConstraint(stringUuid(options) as IConstraint<T>);\n\t}\n\n\tpublic regex(regex: RegExp): this {\n\t\treturn this.addConstraint(stringRegex(regex) as IConstraint<T>);\n\t}\n\n\tpublic get date() {\n\t\treturn this.addConstraint(stringDate() as IConstraint<T>);\n\t}\n\n\tpublic get ipv4(): this {\n\t\treturn this.ip(4);\n\t}\n\n\tpublic get ipv6(): this {\n\t\treturn this.ip(6);\n\t}\n\n\tpublic ip(version?: 4 | 6): this {\n\t\treturn this.addConstraint(stringIp(version) as IConstraint<T>);\n\t}\n\n\tpublic phone(): this {\n\t\treturn this.addConstraint(stringPhone() as IConstraint<T>);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'string' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.string', 'Expected a string primitive', value));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class TupleValidator<T extends any[]> extends BaseValidator<[...T]> {\n\tprivate readonly validators: BaseValidator<[...T]>[] = [];\n\n\tpublic constructor(validators: BaseValidator<[...T]>[], constraints: readonly IConstraint<[...T]>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validators = validators;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validators, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<[...T], ValidationError | CombinedPropertyError> {\n\t\tif (!Array.isArray(values)) {\n\t\t\treturn Result.err(new ValidationError('s.tuple(T)', 'Expected an array', values));\n\t\t}\n\n\t\tif (values.length !== this.validators.length) {\n\t\t\treturn Result.err(new ValidationError('s.tuple(T)', `Expected an array of length ${this.validators.length}`, values));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(values as [...T]);\n\t\t}\n\n\t\tconst errors: [number, BaseError][] = [];\n\t\tconst transformed: T = [] as unknown as T;\n\n\t\tfor (let i = 0; i < values.length; i++) {\n\t\t\tconst result = this.validators[i].run(values[i]);\n\t\t\tif (result.isOk()) transformed.push(result.value);\n\t\t\telse errors.push([i, result.error!]);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class MapValidator<K, V> extends BaseValidator<Map<K, V>> {\n\tprivate readonly keyValidator: BaseValidator<K>;\n\tprivate readonly valueValidator: BaseValidator<V>;\n\n\tpublic constructor(keyValidator: BaseValidator<K>, valueValidator: BaseValidator<V>, constraints: readonly IConstraint<Map<K, V>>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.keyValidator = keyValidator;\n\t\tthis.valueValidator = valueValidator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.keyValidator, this.valueValidator, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<Map<K, V>, ValidationError | CombinedPropertyError> {\n\t\tif (!(value instanceof Map)) {\n\t\t\treturn Result.err(new ValidationError('s.map(K, V)', 'Expected a map', value));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(value);\n\t\t}\n\n\t\tconst errors: [string, BaseError][] = [];\n\t\tconst transformed = new Map<K, V>();\n\n\t\tfor (const [key, val] of value.entries()) {\n\t\t\tconst keyResult = this.keyValidator.run(key);\n\t\t\tconst valueResult = this.valueValidator.run(val);\n\t\t\tconst { length } = errors;\n\t\t\tif (keyResult.isErr()) errors.push([key, keyResult.error]);\n\t\t\tif (valueResult.isErr()) errors.push([key, valueResult.error]);\n\t\t\tif (errors.length === length) transformed.set(keyResult.value!, valueResult.value!);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import type { Result } from '../lib/Result';\nimport type { IConstraint, Unwrap } from '../type-exports';\nimport { BaseValidator, type ValidatorError } from './imports';\n\nexport class LazyValidator<T extends BaseValidator<unknown>, R = Unwrap<T>> extends BaseValidator<R> {\n\tprivate readonly validator: (value: unknown) => T;\n\n\tpublic constructor(validator: (value: unknown) => T, constraints: readonly IConstraint<R>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<R, ValidatorError> {\n\t\treturn this.validator(values).run(values) as Result<R, ValidatorError>;\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class UnknownEnumValueError extends BaseError {\n\tpublic readonly value: string | number;\n\tpublic readonly enumKeys: string[];\n\tpublic readonly enumMappings: Map<string | number, string | number>;\n\n\tpublic constructor(value: string | number, keys: string[], enumMappings: Map<string | number, string | number>) {\n\t\tsuper('Expected the value to be one of the following enum values:');\n\n\t\tthis.value = value;\n\t\tthis.enumKeys = keys;\n\t\tthis.enumMappings = enumMappings;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tvalue: this.value,\n\t\t\tenumKeys: this.enumKeys,\n\t\t\tenumMappings: [...this.enumMappings.entries()]\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst value = options.stylize(this.value.toString(), 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[UnknownEnumValueError: ${value}]`, 'special');\n\t\t}\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst pairs = this.enumKeys\n\t\t\t.map((key) => {\n\t\t\t\tconst enumValue = this.enumMappings.get(key)!;\n\t\t\t\treturn `${options.stylize(key, 'string')} or ${options.stylize(\n\t\t\t\t\tenumValue.toString(),\n\t\t\t\t\ttypeof enumValue === 'number' ? 'number' : 'string'\n\t\t\t\t)}`;\n\t\t\t})\n\t\t\t.join(padding);\n\n\t\tconst header = `${options.stylize('UnknownEnumValueError', 'special')} > ${value}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst pairsBlock = `${padding}${pairs}`;\n\t\treturn `${header}\\n ${message}\\n${pairsBlock}`;\n\t}\n}\n","import { UnknownEnumValueError } from '../lib/errors/UnknownEnumValueError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NativeEnumValidator<T extends NativeEnumLike> extends BaseValidator<T[keyof T]> {\n\tpublic readonly enumShape: T;\n\tpublic readonly hasNumericElements: boolean = false;\n\tprivate readonly enumKeys: string[];\n\tprivate readonly enumMapping = new Map<string | number, T[keyof T]>();\n\n\tpublic constructor(enumShape: T) {\n\t\tsuper();\n\t\tthis.enumShape = enumShape;\n\n\t\tthis.enumKeys = Object.keys(enumShape).filter((key) => {\n\t\t\treturn typeof enumShape[enumShape[key]] !== 'number';\n\t\t});\n\n\t\tfor (const key of this.enumKeys) {\n\t\t\tconst enumValue = enumShape[key] as T[keyof T];\n\n\t\t\tthis.enumMapping.set(key, enumValue);\n\t\t\tthis.enumMapping.set(enumValue, enumValue);\n\n\t\t\tif (typeof enumValue === 'number') {\n\t\t\t\tthis.hasNumericElements = true;\n\t\t\t\tthis.enumMapping.set(`${enumValue}`, enumValue);\n\t\t\t}\n\t\t}\n\t}\n\n\tprotected override handle(value: unknown): Result<T[keyof T], ValidationError | UnknownEnumValueError> {\n\t\tconst typeOfValue = typeof value;\n\n\t\tif (typeOfValue === 'number') {\n\t\t\tif (!this.hasNumericElements) {\n\t\t\t\treturn Result.err(new ValidationError('s.nativeEnum(T)', 'Expected the value to be a string', value));\n\t\t\t}\n\t\t} else if (typeOfValue !== 'string') {\n\t\t\t// typeOfValue !== 'number' is implied here\n\t\t\treturn Result.err(new ValidationError('s.nativeEnum(T)', 'Expected the value to be a string or number', value));\n\t\t}\n\n\t\tconst casted = value as string | number;\n\n\t\tconst possibleEnumValue = this.enumMapping.get(casted);\n\n\t\treturn typeof possibleEnumValue === 'undefined'\n\t\t\t? Result.err(new UnknownEnumValueError(casted, this.enumKeys, this.enumMapping))\n\t\t\t: Result.ok(possibleEnumValue);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.enumShape]);\n\t}\n}\n\nexport interface NativeEnumLike {\n\t[key: string]: string | number;\n\t[key: number]: string;\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\nimport type { TypedArray } from './util/typedArray';\n\nexport type TypedArrayConstraintName = `s.typedArray(T).${'byteLength' | 'length'}${\n\t| 'LessThan'\n\t| 'LessThanOrEqual'\n\t| 'GreaterThan'\n\t| 'GreaterThanOrEqual'\n\t| 'Equal'\n\t| 'NotEqual'\n\t| 'Range'\n\t| 'RangeInclusive'\n\t| 'RangeExclusive'}`;\n\nfunction typedArrayByteLengthComparator<T extends TypedArray>(\n\tcomparator: Comparator,\n\tname: TypedArrayConstraintName,\n\texpected: string,\n\tlength: number\n): IConstraint<T> {\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn comparator(input.byteLength, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Typed Array byte length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayByteLengthLessThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength < ${value}`;\n\treturn typedArrayByteLengthComparator(lessThan, 's.typedArray(T).byteLengthLessThan', expected, value);\n}\n\nexport function typedArrayByteLengthLessThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength <= ${value}`;\n\treturn typedArrayByteLengthComparator(lessThanOrEqual, 's.typedArray(T).byteLengthLessThanOrEqual', expected, value);\n}\n\nexport function typedArrayByteLengthGreaterThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength > ${value}`;\n\treturn typedArrayByteLengthComparator(greaterThan, 's.typedArray(T).byteLengthGreaterThan', expected, value);\n}\n\nexport function typedArrayByteLengthGreaterThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength >= ${value}`;\n\treturn typedArrayByteLengthComparator(greaterThanOrEqual, 's.typedArray(T).byteLengthGreaterThanOrEqual', expected, value);\n}\n\nexport function typedArrayByteLengthEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength === ${value}`;\n\treturn typedArrayByteLengthComparator(equal, 's.typedArray(T).byteLengthEqual', expected, value);\n}\n\nexport function typedArrayByteLengthNotEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength !== ${value}`;\n\treturn typedArrayByteLengthComparator(notEqual, 's.typedArray(T).byteLengthNotEqual', expected, value);\n}\n\nexport function typedArrayByteLengthRange<T extends TypedArray>(start: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.byteLength >= ${start} && expected.byteLength < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.byteLength >= start && input.byteLength < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).byteLengthRange', 'Invalid Typed Array byte length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayByteLengthRangeInclusive<T extends TypedArray>(start: number, end: number) {\n\tconst expected = `expected.byteLength >= ${start} && expected.byteLength <= ${end}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.byteLength >= start && input.byteLength <= end //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(\n\t\t\t\t\t\tnew ExpectedConstraintError('s.typedArray(T).byteLengthRangeInclusive', 'Invalid Typed Array byte length', input, expected)\n\t\t\t\t );\n\t\t}\n\t};\n}\n\nexport function typedArrayByteLengthRangeExclusive<T extends TypedArray>(startAfter: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.byteLength > ${startAfter} && expected.byteLength < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.byteLength > startAfter && input.byteLength < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(\n\t\t\t\t\t\tnew ExpectedConstraintError('s.typedArray(T).byteLengthRangeExclusive', 'Invalid Typed Array byte length', input, expected)\n\t\t\t\t );\n\t\t}\n\t};\n}\n\nfunction typedArrayLengthComparator<T extends TypedArray>(\n\tcomparator: Comparator,\n\tname: TypedArrayConstraintName,\n\texpected: string,\n\tlength: number\n): IConstraint<T> {\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn comparator(input.length, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayLengthLessThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length < ${value}`;\n\treturn typedArrayLengthComparator(lessThan, 's.typedArray(T).lengthLessThan', expected, value);\n}\n\nexport function typedArrayLengthLessThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length <= ${value}`;\n\treturn typedArrayLengthComparator(lessThanOrEqual, 's.typedArray(T).lengthLessThanOrEqual', expected, value);\n}\n\nexport function typedArrayLengthGreaterThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length > ${value}`;\n\treturn typedArrayLengthComparator(greaterThan, 's.typedArray(T).lengthGreaterThan', expected, value);\n}\n\nexport function typedArrayLengthGreaterThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length >= ${value}`;\n\treturn typedArrayLengthComparator(greaterThanOrEqual, 's.typedArray(T).lengthGreaterThanOrEqual', expected, value);\n}\n\nexport function typedArrayLengthEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length === ${value}`;\n\treturn typedArrayLengthComparator(equal, 's.typedArray(T).lengthEqual', expected, value);\n}\n\nexport function typedArrayLengthNotEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length !== ${value}`;\n\treturn typedArrayLengthComparator(notEqual, 's.typedArray(T).lengthNotEqual', expected, value);\n}\n\nexport function typedArrayLengthRange<T extends TypedArray>(start: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.length >= ${start} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.length >= start && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).lengthRange', 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayLengthRangeInclusive<T extends TypedArray>(start: number, end: number): IConstraint<T> {\n\tconst expected = `expected.length >= ${start} && expected.length <= ${end}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.length >= start && input.length <= end //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).lengthRangeInclusive', 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayLengthRangeExclusive<T extends TypedArray>(startAfter: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.length > ${startAfter} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.length > startAfter && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).lengthRangeExclusive', 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n","const vowels = ['a', 'e', 'i', 'o', 'u'];\n\nexport const aOrAn = (word: string) => {\n\treturn `${vowels.includes(word[0].toLowerCase()) ? 'an' : 'a'} ${word}`;\n};\n","export type TypedArray =\n\t| Int8Array\n\t| Uint8Array\n\t| Uint8ClampedArray\n\t| Int16Array\n\t| Uint16Array\n\t| Int32Array\n\t| Uint32Array\n\t| Float32Array\n\t| Float64Array\n\t| BigInt64Array\n\t| BigUint64Array;\n\nexport const TypedArrays = {\n\tInt8Array: (x: unknown): x is Int8Array => x instanceof Int8Array,\n\tUint8Array: (x: unknown): x is Uint8Array => x instanceof Uint8Array,\n\tUint8ClampedArray: (x: unknown): x is Uint8ClampedArray => x instanceof Uint8ClampedArray,\n\tInt16Array: (x: unknown): x is Int16Array => x instanceof Int16Array,\n\tUint16Array: (x: unknown): x is Uint16Array => x instanceof Uint16Array,\n\tInt32Array: (x: unknown): x is Int32Array => x instanceof Int32Array,\n\tUint32Array: (x: unknown): x is Uint32Array => x instanceof Uint32Array,\n\tFloat32Array: (x: unknown): x is Float32Array => x instanceof Float32Array,\n\tFloat64Array: (x: unknown): x is Float64Array => x instanceof Float64Array,\n\tBigInt64Array: (x: unknown): x is BigInt64Array => x instanceof BigInt64Array,\n\tBigUint64Array: (x: unknown): x is BigUint64Array => x instanceof BigUint64Array,\n\tTypedArray: (x: unknown): x is TypedArray => ArrayBuffer.isView(x) && !(x instanceof DataView)\n} as const;\n\nexport type TypedArrayName = keyof typeof TypedArrays;\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\ttypedArrayByteLengthEqual,\n\ttypedArrayByteLengthGreaterThan,\n\ttypedArrayByteLengthGreaterThanOrEqual,\n\ttypedArrayByteLengthLessThan,\n\ttypedArrayByteLengthLessThanOrEqual,\n\ttypedArrayByteLengthNotEqual,\n\ttypedArrayByteLengthRange,\n\ttypedArrayByteLengthRangeExclusive,\n\ttypedArrayByteLengthRangeInclusive,\n\ttypedArrayLengthEqual,\n\ttypedArrayLengthGreaterThan,\n\ttypedArrayLengthGreaterThanOrEqual,\n\ttypedArrayLengthLessThan,\n\ttypedArrayLengthLessThanOrEqual,\n\ttypedArrayLengthNotEqual,\n\ttypedArrayLengthRange,\n\ttypedArrayLengthRangeExclusive,\n\ttypedArrayLengthRangeInclusive\n} from '../constraints/TypedArrayLengthConstraints';\nimport { aOrAn } from '../constraints/util/common/vowels';\nimport { TypedArrays, type TypedArray, type TypedArrayName } from '../constraints/util/typedArray';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class TypedArrayValidator<T extends TypedArray> extends BaseValidator<T> {\n\tprivate readonly type: TypedArrayName;\n\n\tpublic constructor(type: TypedArrayName, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.type = type;\n\t}\n\n\tpublic byteLengthLessThan(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthLessThan(length));\n\t}\n\n\tpublic byteLengthLessThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthLessThanOrEqual(length));\n\t}\n\n\tpublic byteLengthGreaterThan(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthGreaterThan(length));\n\t}\n\n\tpublic byteLengthGreaterThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthGreaterThanOrEqual(length));\n\t}\n\n\tpublic byteLengthEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthEqual(length));\n\t}\n\n\tpublic byteLengthNotEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthNotEqual(length));\n\t}\n\n\tpublic byteLengthRange(start: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthRange(start, endBefore));\n\t}\n\n\tpublic byteLengthRangeInclusive(startAt: number, endAt: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthRangeInclusive(startAt, endAt) as IConstraint<T>);\n\t}\n\n\tpublic byteLengthRangeExclusive(startAfter: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthRangeExclusive(startAfter, endBefore));\n\t}\n\n\tpublic lengthLessThan(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthLessThan(length));\n\t}\n\n\tpublic lengthLessThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthLessThanOrEqual(length));\n\t}\n\n\tpublic lengthGreaterThan(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthGreaterThan(length));\n\t}\n\n\tpublic lengthGreaterThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthGreaterThanOrEqual(length));\n\t}\n\n\tpublic lengthEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthEqual(length));\n\t}\n\n\tpublic lengthNotEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthNotEqual(length));\n\t}\n\n\tpublic lengthRange(start: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayLengthRange(start, endBefore));\n\t}\n\n\tpublic lengthRangeInclusive(startAt: number, endAt: number) {\n\t\treturn this.addConstraint(typedArrayLengthRangeInclusive(startAt, endAt));\n\t}\n\n\tpublic lengthRangeExclusive(startAfter: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayLengthRangeExclusive(startAfter, endBefore));\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.type, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn TypedArrays[this.type](value)\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.typedArray', `Expected ${aOrAn(this.type)}`, value));\n\t}\n}\n","import type { TypedArray, TypedArrayName } from '../constraints/util/typedArray';\nimport type { Unwrap, UnwrapTuple } from '../lib/util-types';\nimport {\n\tArrayValidator,\n\tBaseValidator,\n\tBigIntValidator,\n\tBooleanValidator,\n\tDateValidator,\n\tInstanceValidator,\n\tLiteralValidator,\n\tMapValidator,\n\tNeverValidator,\n\tNullishValidator,\n\tNumberValidator,\n\tObjectValidator,\n\tPassthroughValidator,\n\tRecordValidator,\n\tSetValidator,\n\tStringValidator,\n\tTupleValidator,\n\tUnionValidator\n} from '../validators/imports';\nimport { LazyValidator } from '../validators/LazyValidator';\nimport { NativeEnumValidator, type NativeEnumLike } from '../validators/NativeEnumValidator';\nimport { TypedArrayValidator } from '../validators/TypedArrayValidator';\nimport type { Constructor, MappedObjectValidator } from './util-types';\n\nexport class Shapes {\n\tpublic get string() {\n\t\treturn new StringValidator();\n\t}\n\n\tpublic get number() {\n\t\treturn new NumberValidator();\n\t}\n\n\tpublic get bigint() {\n\t\treturn new BigIntValidator();\n\t}\n\n\tpublic get boolean() {\n\t\treturn new BooleanValidator();\n\t}\n\n\tpublic get date() {\n\t\treturn new DateValidator();\n\t}\n\n\tpublic object<T extends object>(shape: MappedObjectValidator<T>) {\n\t\treturn new ObjectValidator<T>(shape);\n\t}\n\n\tpublic get undefined() {\n\t\treturn this.literal(undefined);\n\t}\n\n\tpublic get null() {\n\t\treturn this.literal(null);\n\t}\n\n\tpublic get nullish() {\n\t\treturn new NullishValidator();\n\t}\n\n\tpublic get any() {\n\t\treturn new PassthroughValidator<any>();\n\t}\n\n\tpublic get unknown() {\n\t\treturn new PassthroughValidator<unknown>();\n\t}\n\n\tpublic get never() {\n\t\treturn new NeverValidator();\n\t}\n\n\tpublic enum<T>(...values: readonly T[]) {\n\t\treturn this.union(...values.map((value) => this.literal(value)));\n\t}\n\n\tpublic nativeEnum<T extends NativeEnumLike>(enumShape: T): NativeEnumValidator<T> {\n\t\treturn new NativeEnumValidator(enumShape);\n\t}\n\n\tpublic literal<T>(value: T): BaseValidator<T> {\n\t\tif (value instanceof Date) return this.date.equal(value) as unknown as BaseValidator<T>;\n\t\treturn new LiteralValidator(value);\n\t}\n\n\tpublic instance<T>(expected: Constructor<T>): InstanceValidator<T> {\n\t\treturn new InstanceValidator(expected);\n\t}\n\n\tpublic union<T extends [...BaseValidator<any>[]]>(...validators: [...T]): UnionValidator<Unwrap<T[number]>> {\n\t\treturn new UnionValidator(validators);\n\t}\n\n\tpublic array<T>(validator: BaseValidator<T[][number]>): ArrayValidator<T[], T[][number]>;\n\tpublic array<T extends unknown[]>(validator: BaseValidator<T[number]>): ArrayValidator<T, T[number]>;\n\tpublic array<T extends unknown[]>(validator: BaseValidator<T[number]>) {\n\t\treturn new ArrayValidator(validator);\n\t}\n\n\tpublic typedArray<T extends TypedArray>(type: TypedArrayName = 'TypedArray') {\n\t\treturn new TypedArrayValidator<T>(type);\n\t}\n\n\tpublic get int8Array() {\n\t\treturn this.typedArray<Int8Array>('Int8Array');\n\t}\n\n\tpublic get uint8Array() {\n\t\treturn this.typedArray<Uint8Array>('Uint8Array');\n\t}\n\n\tpublic get uint8ClampedArray() {\n\t\treturn this.typedArray<Uint8ClampedArray>('Uint8ClampedArray');\n\t}\n\n\tpublic get int16Array() {\n\t\treturn this.typedArray<Int16Array>('Int16Array');\n\t}\n\n\tpublic get uint16Array() {\n\t\treturn this.typedArray<Uint16Array>('Uint16Array');\n\t}\n\n\tpublic get int32Array() {\n\t\treturn this.typedArray<Int32Array>('Int32Array');\n\t}\n\n\tpublic get uint32Array() {\n\t\treturn this.typedArray<Uint32Array>('Uint32Array');\n\t}\n\n\tpublic get float32Array() {\n\t\treturn this.typedArray<Float32Array>('Float32Array');\n\t}\n\n\tpublic get float64Array() {\n\t\treturn this.typedArray<Float64Array>('Float64Array');\n\t}\n\n\tpublic get bigInt64Array() {\n\t\treturn this.typedArray<BigInt64Array>('BigInt64Array');\n\t}\n\n\tpublic get bigUint64Array() {\n\t\treturn this.typedArray<BigUint64Array>('BigUint64Array');\n\t}\n\n\tpublic tuple<T extends [...BaseValidator<any>[]]>(validators: [...T]): TupleValidator<UnwrapTuple<T>> {\n\t\treturn new TupleValidator(validators);\n\t}\n\n\tpublic set<T>(validator: BaseValidator<T>) {\n\t\treturn new SetValidator(validator);\n\t}\n\n\tpublic record<T>(validator: BaseValidator<T>) {\n\t\treturn new RecordValidator(validator);\n\t}\n\n\tpublic map<T, U>(keyValidator: BaseValidator<T>, valueValidator: BaseValidator<U>) {\n\t\treturn new MapValidator(keyValidator, valueValidator);\n\t}\n\n\tpublic lazy<T extends BaseValidator<unknown>>(validator: (value: unknown) => T) {\n\t\treturn new LazyValidator(validator);\n\t}\n}\n","import { Shapes } from './lib/Shapes';\n\nexport const s = new Shapes();\n\nexport * from './lib/Result';\nexport * from './lib/configs';\nexport * from './lib/errors/BaseError';\nexport * from './lib/errors/CombinedError';\nexport * from './lib/errors/CombinedPropertyError';\nexport * from './lib/errors/ExpectedConstraintError';\nexport * from './lib/errors/ExpectedValidationError';\nexport * from './lib/errors/MissingPropertyError';\nexport * from './lib/errors/MultiplePossibilitiesConstraintError';\nexport * from './lib/errors/UnknownEnumValueError';\nexport * from './lib/errors/UnknownPropertyError';\nexport * from './lib/errors/ValidationError';\nexport * from './type-exports';\n"]}
\ No newline at end of file diff --git a/node_modules/@sapphire/shapeshift/dist/index.mjs b/node_modules/@sapphire/shapeshift/dist/index.mjs new file mode 100644 index 0000000..fb53e6e --- /dev/null +++ b/node_modules/@sapphire/shapeshift/dist/index.mjs @@ -0,0 +1,2219 @@ +import get from 'lodash/get.js'; +import { inspect } from 'util'; +import fastDeepEqual from 'fast-deep-equal/es6/index.js'; +import uniqWith from 'lodash/uniqWith.js'; + +var __defProp = Object.defineProperty; +var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); + +// 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/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 = inspect(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((k) => get(parent, k)) : get(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((v, constraint) => constraint.run(v).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"); +function isUnique(input) { + if (input.length < 2) + return true; + const uniqueArray2 = uniqWith(input, fastDeepEqual); + return uniqueArray2.length === input.length; +} +__name(isUnique, "isUnique"); + +// src/constraints/util/operators.ts +function lessThan(a, b) { + return a < b; +} +__name(lessThan, "lessThan"); +function lessThanOrEqual(a, b) { + return a <= b; +} +__name(lessThanOrEqual, "lessThanOrEqual"); +function greaterThan(a, b) { + return a > b; +} +__name(greaterThan, "greaterThan"); +function greaterThanOrEqual(a, b) { + return a >= b; +} +__name(greaterThanOrEqual, "greaterThanOrEqual"); +function equal(a, b) { + return a === b; +} +__name(equal, "equal"); +function notEqual(a, b) { + return a !== b; +} +__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"); +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 = inspect(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 i = 0; i < values.length; i++) { + const result = this.validator.run(values[i]); + if (result.isOk()) + transformed.push(result.value); + else + errors.push([i, 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"); +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 = inspect(this.expected, newOptions).replace(/\n/g, padding); + const given = inspect(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"); +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 = inspect(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, i) => { + const index = options.stylize((i + 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(s2) { + return IPv4Reg.test(s2); +} +__name(isIPv4, "isIPv4"); +function isIPv6(s2) { + return IPv6Reg.test(s2); +} +__name(isIPv6, "isIPv6"); +function isIP(s2) { + if (isIPv4(s2)) + return 4; + if (isIPv6(s2)) + 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"); +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 = inspect(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 i = 0; i < values.length; i++) { + const result = this.validators[i].run(values[i]); + if (result.isOk()) + transformed.push(result.value); + else + errors.push([i, 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: (x) => x instanceof Int8Array, + Uint8Array: (x) => x instanceof Uint8Array, + Uint8ClampedArray: (x) => x instanceof Uint8ClampedArray, + Int16Array: (x) => x instanceof Int16Array, + Uint16Array: (x) => x instanceof Uint16Array, + Int32Array: (x) => x instanceof Int32Array, + Uint32Array: (x) => x instanceof Uint32Array, + Float32Array: (x) => x instanceof Float32Array, + Float64Array: (x) => x instanceof Float64Array, + BigInt64Array: (x) => x instanceof BigInt64Array, + BigUint64Array: (x) => x instanceof BigUint64Array, + TypedArray: (x) => ArrayBuffer.isView(x) && !(x 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 s = new Shapes(); + +export { BaseError, CombinedError, CombinedPropertyError, ExpectedConstraintError, ExpectedValidationError, MissingPropertyError, MultiplePossibilitiesConstraintError, Result, UnknownEnumValueError, UnknownPropertyError, ValidationError, customInspectSymbol, customInspectSymbolStackLess, getGlobalValidationEnabled, s, setGlobalValidationEnabled }; +//# sourceMappingURL=out.js.map +//# sourceMappingURL=index.mjs.map
\ No newline at end of file diff --git a/node_modules/@sapphire/shapeshift/dist/index.mjs.map b/node_modules/@sapphire/shapeshift/dist/index.mjs.map new file mode 100644 index 0000000..46db7f3 --- /dev/null +++ b/node_modules/@sapphire/shapeshift/dist/index.mjs.map @@ -0,0 +1 @@ +{"version":3,"sources":["../src/lib/configs.ts","../src/lib/Result.ts","../src/validators/util/getValue.ts","../src/constraints/ObjectConstrains.ts","../src/lib/errors/ExpectedConstraintError.ts","../src/lib/errors/BaseError.ts","../src/lib/errors/BaseConstraintError.ts","../src/validators/BaseValidator.ts","../src/constraints/util/isUnique.ts","../src/constraints/util/operators.ts","../src/constraints/ArrayConstraints.ts","../src/lib/errors/CombinedPropertyError.ts","../src/lib/errors/ValidationError.ts","../src/validators/ArrayValidator.ts","../src/constraints/BigIntConstraints.ts","../src/validators/BigIntValidator.ts","../src/constraints/BooleanConstraints.ts","../src/validators/BooleanValidator.ts","../src/constraints/DateConstraints.ts","../src/validators/DateValidator.ts","../src/lib/errors/ExpectedValidationError.ts","../src/validators/InstanceValidator.ts","../src/validators/LiteralValidator.ts","../src/validators/NeverValidator.ts","../src/validators/NullishValidator.ts","../src/constraints/NumberConstraints.ts","../src/validators/NumberValidator.ts","../src/lib/errors/MissingPropertyError.ts","../src/lib/errors/UnknownPropertyError.ts","../src/validators/DefaultValidator.ts","../src/lib/errors/CombinedError.ts","../src/validators/UnionValidator.ts","../src/validators/ObjectValidator.ts","../src/validators/PassthroughValidator.ts","../src/validators/RecordValidator.ts","../src/validators/SetValidator.ts","../src/constraints/util/emailValidator.ts","../src/constraints/util/net.ts","../src/constraints/util/phoneValidator.ts","../src/lib/errors/MultiplePossibilitiesConstraintError.ts","../src/constraints/util/common/combinedResultFn.ts","../src/constraints/util/urlValidators.ts","../src/constraints/StringConstraints.ts","../src/validators/StringValidator.ts","../src/validators/TupleValidator.ts","../src/validators/MapValidator.ts","../src/validators/LazyValidator.ts","../src/lib/errors/UnknownEnumValueError.ts","../src/validators/NativeEnumValidator.ts","../src/constraints/TypedArrayLengthConstraints.ts","../src/constraints/util/common/vowels.ts","../src/constraints/util/typedArray.ts","../src/validators/TypedArrayValidator.ts","../src/lib/Shapes.ts","../src/index.ts"],"names":["uniqueArray","inspect","value","s"],"mappings":";;;;AAAA,IAAI,oBAAoB;AAMjB,SAAS,2BAA2B,SAAkB;AAC5D,sBAAoB;AACrB;AAFgB;AAOT,SAAS,6BAA6B;AAC5C,SAAO;AACR;AAFgB;;;ACbT,IAAM,SAAN,MAAyC;AAAA,EAKvC,YAAY,SAAkB,OAAW,OAAW;AAC3D,SAAK,UAAU;AACf,QAAI,SAAS;AACZ,WAAK,QAAQ;AAAA,IACd,OAAO;AACN,WAAK,QAAQ;AAAA,IACd;AAAA,EACD;AAAA,EAEO,OAA4C;AAClD,WAAO,KAAK;AAAA,EACb;AAAA,EAEO,QAA8C;AACpD,WAAO,CAAC,KAAK;AAAA,EACd;AAAA,EAEO,SAAY;AAClB,QAAI,KAAK,KAAK;AAAG,aAAO,KAAK;AAC7B,UAAM,KAAK;AAAA,EACZ;AAAA,EAEA,OAAc,GAA+B,OAAwB;AACpE,WAAO,IAAI,OAAa,MAAM,KAAK;AAAA,EACpC;AAAA,EAEA,OAAc,IAAgC,OAAwB;AACrE,WAAO,IAAI,OAAa,OAAO,QAAW,KAAK;AAAA,EAChD;AACD;AAlCa;;;ACGN,SAAS,SAAkD,WAAiB;AAClF,SAAO,OAAO,cAAc,aAAa,UAAU,IAAI;AACxD;AAFgB;;;ACHhB,OAAO,SAAS;;;ACAhB,SAAS,eAA4C;;;ACE9C,IAAM,sBAAsB,OAAO,IAAI,4BAA4B;AACnE,IAAM,+BAA+B,OAAO,IAAI,uCAAuC;AAEvF,IAAe,YAAf,cAAiC,MAAM;AAAA,EAC7C,CAAW,mBAAmB,EAAE,OAAe,SAAiC;AAC/E,WAAO,GAAG,KAAK,4BAA4B,EAAE,OAAO,OAAO;AAAA,EAAM,KAAK,MAAO,MAAM,KAAK,MAAO,QAAQ,IAAI,CAAC;AAAA,EAC7G;AAGD;AANsB;;;ACiBf,IAAe,sBAAf,cAAwD,UAAU;AAAA,EAIjE,YAAY,YAAkC,SAAiB,OAAU;AAC/E,UAAM,OAAO;AACb,SAAK,aAAa;AAClB,SAAK,QAAQ;AAAA,EACd;AACD;AATsB;;;AFlBf,IAAM,0BAAN,cAAmD,oBAAuB;AAAA,EAGzE,YAAY,YAAkC,SAAiB,OAAU,UAAkB;AACjG,UAAM,YAAY,SAAS,KAAK;AAChC,SAAK,WAAW;AAAA,EACjB;AAAA,EAEO,SAAS;AACf,WAAO;AAAA,MACN,MAAM,KAAK;AAAA,MACX,YAAY,KAAK;AAAA,MACjB,OAAO,KAAK;AAAA,MACZ,UAAU,KAAK;AAAA,IAChB;AAAA,EACD;AAAA,EAEA,CAAW,4BAA4B,EAAE,OAAe,SAAyC;AAChG,UAAM,aAAa,QAAQ,QAAQ,KAAK,YAAY,QAAQ;AAC5D,QAAI,QAAQ,GAAG;AACd,aAAO,QAAQ,QAAQ,6BAA6B,eAAe,SAAS;AAAA,IAC7E;AAEA,UAAM,aAAa,EAAE,GAAG,SAAS,OAAO,QAAQ,UAAU,OAAO,OAAO,QAAQ,QAAS,EAAE;AAE3F,UAAM,UAAU;AAAA,IAAO,QAAQ,QAAQ,KAAK,WAAW;AACvD,UAAM,QAAQ,QAAQ,KAAK,OAAO,UAAU,EAAE,QAAQ,OAAO,OAAO;AAEpE,UAAM,SAAS,GAAG,QAAQ,QAAQ,2BAA2B,SAAS,OAAO;AAC7E,UAAM,UAAU,QAAQ,QAAQ,KAAK,SAAS,QAAQ;AACtD,UAAM,gBAAgB;AAAA,IAAO,QAAQ,QAAQ,cAAc,QAAQ,IAAI,QAAQ,QAAQ,KAAK,UAAU,SAAS;AAC/G,UAAM,aAAa;AAAA,IAAO,QAAQ,QAAQ,aAAa,QAAQ,IAAI,UAAU;AAC7E,WAAO,GAAG;AAAA,IAAa;AAAA,EAAY;AAAA,EAAkB;AAAA,EACtD;AACD;AAlCa;;;ADYN,SAAS,eACf,KACA,SACA,WACiB;AACjB,SAAO;AAAA,IACN,IAAI,OAAU,QAAc;AAC3B,UAAI,CAAC,QAAQ;AACZ,eAAO,OAAO,IAAI,IAAI,wBAAwB,oBAAoB,2BAA2B,QAAQ,4BAA4B,CAAC;AAAA,MACnI;AAEA,YAAM,aAAa,MAAM,QAAQ,GAAG;AAEpC,YAAM,QAAQ,aAAa,IAAI,IAAI,CAAC,MAAM,IAAI,QAAQ,CAAC,CAAC,IAAI,IAAI,QAAQ,GAAG;AAE3E,YAAM,YAAY,iBAAyB,SAAS,OAAO,UAAU,IAAI,QAAQ,OAAO,QAAQ;AAEhG,UAAI,WAAW;AACd,eAAO,UAAU,SAAS,EAAE,IAAI,KAAK;AAAA,MACtC;AAEA,aAAO,OAAO,GAAG,KAAK;AAAA,IACvB;AAAA,EACD;AACD;AAxBgB;AA0BhB,SAAS,iBAAoE,SAA8B,OAAY,YAAqB;AAC3I,MAAI,QAAQ,OAAO,QAAW;AAC7B,WAAO,aAAa,CAAC,MAAM,KAAK,CAAC,QAAa,CAAC,GAAG,IAAI,QAAQ,KAAK;AAAA,EACpE;AAEA,MAAI,OAAO,QAAQ,OAAO,YAAY;AACrC,WAAO,QAAQ,GAAG,KAAK;AAAA,EACxB;AAEA,SAAO,UAAU,QAAQ;AAC1B;AAVS;;;AI7BF,IAAe,gBAAf,MAAgC;AAAA,EAM/B,YAAY,cAAyC,CAAC,GAAG;AAHhE,SAAU,cAAyC,CAAC;AACpD,SAAU,sBAAwD;AAGjE,SAAK,cAAc;AAAA,EACpB;AAAA,EAEO,UAAU,QAAsB;AACtC,SAAK,SAAS;AACd,WAAO;AAAA,EACR;AAAA,EAEA,IAAW,WAA0C;AACpD,WAAO,IAAI,eAAe,CAAC,IAAI,iBAAiB,MAAS,GAAG,KAAK,MAAM,CAAC,CAAC;AAAA,EAC1E;AAAA,EAEA,IAAW,WAAqC;AAC/C,WAAO,IAAI,eAAe,CAAC,IAAI,iBAAiB,IAAI,GAAG,KAAK,MAAM,CAAC,CAAC;AAAA,EACrE;AAAA,EAEA,IAAW,UAAgD;AAC1D,WAAO,IAAI,eAAe,CAAC,IAAI,iBAAiB,GAAG,KAAK,MAAM,CAAC,CAAC;AAAA,EACjE;AAAA,EAEA,IAAW,QAA6B;AACvC,WAAO,IAAI,eAAoB,KAAK,MAAM,CAAC;AAAA,EAC5C;AAAA,EAEA,IAAW,MAAuB;AACjC,WAAO,IAAI,aAAgB,KAAK,MAAM,CAAC;AAAA,EACxC;AAAA,EAEO,MAAS,YAAgE;AAC/E,WAAO,IAAI,eAAsB,CAAC,KAAK,MAAM,GAAG,GAAG,UAAU,CAAC;AAAA,EAC/D;AAAA,EAIO,UAAa,IAAuC;AAC1D,WAAO,KAAK,cAAc,EAAE,KAAK,CAAC,UAAU,OAAO,GAAG,GAAG,KAAK,CAAiB,EAAE,CAAC;AAAA,EACnF;AAAA,EAIO,QAA2D,IAAuC;AACxG,WAAO,KAAK,cAAc,EAAE,KAAK,GAAiE,CAAC;AAAA,EACpG;AAAA,EAEO,QAAQ,OAAuG;AACrH,WAAO,IAAI,iBAAiB,KAAK,MAAM,GAAsD,KAAK;AAAA,EACnG;AAAA,EAEO,KAAkE,KAAU,SAAuC;AACzH,WAAO,KAAK,cAAc,eAA6B,KAAK,SAAS,IAAuB,CAAC;AAAA,EAC9F;AAAA,EAEO,SAAS,aAA2B;AAC1C,UAAM,QAAQ,KAAK,MAAM;AACzB,UAAM,cAAc;AACpB,WAAO;AAAA,EACR;AAAA,EAEO,IAAI,OAAsC;AAChD,QAAI,SAAS,KAAK,OAAO,KAAK;AAC9B,QAAI,OAAO,MAAM;AAAG,aAAO;AAE3B,eAAW,cAAc,KAAK,aAAa;AAC1C,eAAS,WAAW,IAAI,OAAO,OAAY,KAAK,MAAM;AACtD,UAAI,OAAO,MAAM;AAAG;AAAA,IACrB;AAEA,WAAO;AAAA,EACR;AAAA,EAEO,MAAuB,OAAmB;AAGhD,QAAI,CAAC,KAAK,sBAAsB;AAC/B,aAAO,KAAK,OAAO,KAAK,EAAE,OAAO;AAAA,IAClC;AAEA,WAAO,KAAK,YAAY,OAAO,CAAC,GAAG,eAAe,WAAW,IAAI,CAAC,EAAE,OAAO,GAAG,KAAK,OAAO,KAAK,EAAE,OAAO,CAAC;AAAA,EAC1G;AAAA,EAEO,GAAoB,OAA4B;AACtD,WAAO,KAAK,IAAI,KAAK,EAAE,KAAK;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,qBAAqB,qBAA6D;AACxF,UAAM,QAAQ,KAAK,MAAM;AACzB,UAAM,sBAAsB;AAC5B,WAAO;AAAA,EACR;AAAA,EAEO,uBAAuB;AAC7B,WAAO,SAAS,KAAK,mBAAmB;AAAA,EACzC;AAAA,EAEA,IAAc,uBAAgC;AAC7C,WAAO,SAAS,KAAK,mBAAmB,KAAK,2BAA2B;AAAA,EACzE;AAAA,EAEU,QAAc;AACvB,UAAM,QAAc,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,WAAW,CAAC;AAC1E,UAAM,sBAAsB,KAAK;AACjC,WAAO;AAAA,EACR;AAAA,EAIU,cAAc,YAAkC;AACzD,UAAM,QAAQ,KAAK,MAAM;AACzB,UAAM,cAAc,MAAM,YAAY,OAAO,UAAU;AACvD,WAAO;AAAA,EACR;AACD;AA3HsB;;;ACbtB,OAAO,mBAAmB;AAC1B,OAAO,cAAc;AAEd,SAAS,SAAS,OAAkB;AAC1C,MAAI,MAAM,SAAS;AAAG,WAAO;AAC7B,QAAMA,eAAc,SAAS,OAAO,aAAa;AACjD,SAAOA,aAAY,WAAW,MAAM;AACrC;AAJgB;;;ACDT,SAAS,SAAS,GAAoB,GAA6B;AACzE,SAAO,IAAI;AACZ;AAFgB;AAMT,SAAS,gBAAgB,GAAoB,GAA6B;AAChF,SAAO,KAAK;AACb;AAFgB;AAMT,SAAS,YAAY,GAAoB,GAA6B;AAC5E,SAAO,IAAI;AACZ;AAFgB;AAMT,SAAS,mBAAmB,GAAoB,GAA6B;AACnF,SAAO,KAAK;AACb;AAFgB;AAMT,SAAS,MAAM,GAAoB,GAA6B;AACtE,SAAO,MAAM;AACd;AAFgB;AAMT,SAAS,SAAS,GAAoB,GAA6B;AACzE,SAAO,MAAM;AACd;AAFgB;;;ACbhB,SAAS,sBAAyB,YAAwB,MAA2B,UAAkB,QAAkC;AACxI,SAAO;AAAA,IACN,IAAI,OAAY;AACf,aAAO,WAAW,MAAM,QAAQ,MAAM,IACnC,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,MAAM,wBAAwB,OAAO,QAAQ,CAAC;AAAA,IACzF;AAAA,EACD;AACD;AARS;AAUF,SAAS,oBAAuB,OAAiC;AACvE,QAAM,WAAW,qBAAqB;AACtC,SAAO,sBAAsB,UAAU,6BAA6B,UAAU,KAAK;AACpF;AAHgB;AAKT,SAAS,2BAA8B,OAAiC;AAC9E,QAAM,WAAW,sBAAsB;AACvC,SAAO,sBAAsB,iBAAiB,oCAAoC,UAAU,KAAK;AAClG;AAHgB;AAKT,SAAS,uBAA0B,OAAiC;AAC1E,QAAM,WAAW,qBAAqB;AACtC,SAAO,sBAAsB,aAAa,gCAAgC,UAAU,KAAK;AAC1F;AAHgB;AAKT,SAAS,8BAAiC,OAAiC;AACjF,QAAM,WAAW,sBAAsB;AACvC,SAAO,sBAAsB,oBAAoB,uCAAuC,UAAU,KAAK;AACxG;AAHgB;AAKT,SAAS,iBAAoB,OAAiC;AACpE,QAAM,WAAW,uBAAuB;AACxC,SAAO,sBAAsB,OAAO,0BAA0B,UAAU,KAAK;AAC9E;AAHgB;AAKT,SAAS,oBAAuB,OAAiC;AACvE,QAAM,WAAW,uBAAuB;AACxC,SAAO,sBAAsB,UAAU,6BAA6B,UAAU,KAAK;AACpF;AAHgB;AAKT,SAAS,iBAAoB,OAAe,WAAqC;AACvF,QAAM,WAAW,sBAAsB,8BAA8B;AACrE,SAAO;AAAA,IACN,IAAI,OAAY;AACf,aAAO,MAAM,UAAU,SAAS,MAAM,SAAS,YAC5C,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,0BAA0B,wBAAwB,OAAO,QAAQ,CAAC;AAAA,IAC7G;AAAA,EACD;AACD;AATgB;AAWT,SAAS,0BAA6B,OAAe,KAA+B;AAC1F,QAAM,WAAW,sBAAsB,+BAA+B;AACtE,SAAO;AAAA,IACN,IAAI,OAAY;AACf,aAAO,MAAM,UAAU,SAAS,MAAM,UAAU,MAC7C,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,mCAAmC,wBAAwB,OAAO,QAAQ,CAAC;AAAA,IACtH;AAAA,EACD;AACD;AATgB;AAWT,SAAS,0BAA6B,YAAoB,WAAqC;AACrG,QAAM,WAAW,qBAAqB,mCAAmC;AACzE,SAAO;AAAA,IACN,IAAI,OAAY;AACf,aAAO,MAAM,SAAS,cAAc,MAAM,SAAS,YAChD,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,mCAAmC,wBAAwB,OAAO,QAAQ,CAAC;AAAA,IACtH;AAAA,EACD;AACD;AATgB;AAWT,IAAM,cAAsC;AAAA,EAClD,IAAI,OAAkB;AACrB,WAAO,SAAS,KAAK,IAClB,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,qBAAqB,+BAA+B,OAAO,kCAAkC,CAAC;AAAA,EACzI;AACD;;;AC/FO,IAAM,wBAAN,cAAoC,UAAU;AAAA,EAG7C,YAAY,QAAoC;AACtD,UAAM,6BAA6B;AAEnC,SAAK,SAAS;AAAA,EACf;AAAA,EAEA,CAAW,4BAA4B,EAAE,OAAe,SAAyC;AAChG,QAAI,QAAQ,GAAG;AACd,aAAO,QAAQ,QAAQ,2BAA2B,SAAS;AAAA,IAC5D;AAEA,UAAM,aAAa,EAAE,GAAG,SAAS,OAAO,QAAQ,UAAU,OAAO,OAAO,QAAQ,QAAS,GAAG,SAAS,KAAK;AAE1G,UAAM,UAAU;AAAA,IAAO,QAAQ,QAAQ,KAAK,WAAW;AAEvD,UAAM,SAAS,GAAG,QAAQ,QAAQ,yBAAyB,SAAS,MAAM,QAAQ,QAAQ,KAAK,OAAO,OAAO,SAAS,GAAG,QAAQ;AACjI,UAAM,UAAU,QAAQ,QAAQ,KAAK,SAAS,QAAQ;AACtD,UAAM,SAAS,KAAK,OAClB,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM;AACtB,YAAM,WAAW,sBAAsB,eAAe,KAAK,OAAO;AAClE,YAAM,OAAO,MAAM,4BAA4B,EAAE,QAAQ,GAAG,UAAU,EAAE,QAAQ,OAAO,OAAO;AAE9F,aAAO,UAAU,WAAW,UAAU;AAAA,IACvC,CAAC,EACA,KAAK,MAAM;AACb,WAAO,GAAG;AAAA,IAAa;AAAA;AAAA,EAAc;AAAA,EACtC;AAAA,EAEA,OAAe,eAAe,KAAkB,SAAyC;AACxF,QAAI,OAAO,QAAQ;AAAU,aAAO,QAAQ,QAAQ,IAAI,OAAO,QAAQ;AACvE,QAAI,OAAO,QAAQ;AAAU,aAAO,IAAI,QAAQ,QAAQ,IAAI,SAAS,GAAG,QAAQ;AAChF,WAAO,IAAI,QAAQ,QAAQ,UAAU,QAAQ,KAAK,IAAI;AAAA,EACvD;AACD;AApCa;;;ACHb,SAAS,WAAAC,gBAA4C;AAG9C,IAAM,kBAAN,cAA8B,UAAU;AAAA,EAIvC,YAAY,WAAmB,SAAiB,OAAgB;AACtE,UAAM,OAAO;AAEb,SAAK,YAAY;AACjB,SAAK,QAAQ;AAAA,EACd;AAAA,EAEO,SAAS;AACf,WAAO;AAAA,MACN,MAAM,KAAK;AAAA,MACX,WAAW,KAAK;AAAA,MAChB,OAAO,KAAK;AAAA,IACb;AAAA,EACD;AAAA,EAEA,CAAW,4BAA4B,EAAE,OAAe,SAAyC;AAChG,UAAM,YAAY,QAAQ,QAAQ,KAAK,WAAW,QAAQ;AAC1D,QAAI,QAAQ,GAAG;AACd,aAAO,QAAQ,QAAQ,qBAAqB,cAAc,SAAS;AAAA,IACpE;AAEA,UAAM,aAAa,EAAE,GAAG,SAAS,OAAO,QAAQ,UAAU,OAAO,OAAO,QAAQ,QAAS,GAAG,SAAS,KAAK;AAE1G,UAAM,UAAU;AAAA,IAAO,QAAQ,QAAQ,KAAK,WAAW;AACvD,UAAM,QAAQA,SAAQ,KAAK,OAAO,UAAU,EAAE,QAAQ,OAAO,OAAO;AAEpE,UAAM,SAAS,GAAG,QAAQ,QAAQ,mBAAmB,SAAS,OAAO;AACrE,UAAM,UAAU,QAAQ,QAAQ,KAAK,SAAS,QAAQ;AACtD,UAAM,aAAa;AAAA,IAAO,QAAQ,QAAQ,aAAa,QAAQ,IAAI,UAAU;AAC7E,WAAO,GAAG;AAAA,IAAa;AAAA,EAAY;AAAA,EACpC;AACD;AAnCa;;;ACiBN,IAAM,iBAAN,cAAiE,cAAiB;AAAA,EAGjF,YAAY,WAA6B,cAAyC,CAAC,GAAG;AAC5F,UAAM,WAAW;AACjB,SAAK,YAAY;AAAA,EAClB;AAAA,EAEO,eAAiC,QAAgF;AACvH,WAAO,KAAK,cAAc,oBAAoB,MAAM,CAAmB;AAAA,EACxE;AAAA,EAEO,sBAAwC,QAAkE;AAChH,WAAO,KAAK,cAAc,2BAA2B,MAAM,CAAmB;AAAA,EAC/E;AAAA,EAEO,kBAAoC,QAAsD;AAChG,WAAO,KAAK,cAAc,uBAAuB,MAAM,CAAmB;AAAA,EAC3E;AAAA,EAEO,yBAA2C,QAAmD;AACpG,WAAO,KAAK,cAAc,8BAA8B,MAAM,CAAmB;AAAA,EAClF;AAAA,EAEO,YAA8B,QAA6C;AACjF,WAAO,KAAK,cAAc,iBAAiB,MAAM,CAAmB;AAAA,EACrE;AAAA,EAEO,eAAe,QAAwC;AAC7D,WAAO,KAAK,cAAc,oBAAoB,MAAM,CAAmB;AAAA,EACxE;AAAA,EAEO,YACN,OACA,WACoI;AACpI,WAAO,KAAK,cAAc,iBAAiB,OAAO,SAAS,CAAmB;AAAA,EAC/E;AAAA,EAEO,qBACN,SACA,OACsH;AACtH,WAAO,KAAK,cAAc,0BAA0B,SAAS,KAAK,CAAmB;AAAA,EACtF;AAAA,EAEO,qBACN,YACA,WACsH;AACtH,WAAO,KAAK,cAAc,0BAA0B,YAAY,SAAS,CAAmB;AAAA,EAC7F;AAAA,EAEA,IAAW,SAAe;AACzB,WAAO,KAAK,cAAc,WAA6B;AAAA,EACxD;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,WAAW,KAAK,WAAW,CAAC;AAAA,EAC9E;AAAA,EAEU,OAAO,QAAqE;AACrF,QAAI,CAAC,MAAM,QAAQ,MAAM,GAAG;AAC3B,aAAO,OAAO,IAAI,IAAI,gBAAgB,cAAc,qBAAqB,MAAM,CAAC;AAAA,IACjF;AAEA,QAAI,CAAC,KAAK,sBAAsB;AAC/B,aAAO,OAAO,GAAG,MAAW;AAAA,IAC7B;AAEA,UAAM,SAAgC,CAAC;AACvC,UAAM,cAAiB,CAAC;AAExB,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACvC,YAAM,SAAS,KAAK,UAAU,IAAI,OAAO,CAAC,CAAC;AAC3C,UAAI,OAAO,KAAK;AAAG,oBAAY,KAAK,OAAO,KAAK;AAAA;AAC3C,eAAO,KAAK,CAAC,GAAG,OAAO,KAAM,CAAC;AAAA,IACpC;AAEA,WAAO,OAAO,WAAW,IACtB,OAAO,GAAG,WAAW,IACrB,OAAO,IAAI,IAAI,sBAAsB,MAAM,CAAC;AAAA,EAChD;AACD;AAnFa;;;ACNb,SAAS,iBAAiB,YAAwB,MAA4B,UAAkB,QAAqC;AACpI,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,aAAO,WAAW,OAAO,MAAM,IAC5B,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,MAAM,wBAAwB,OAAO,QAAQ,CAAC;AAAA,IACzF;AAAA,EACD;AACD;AARS;AAUF,SAAS,eAAe,OAAoC;AAClE,QAAM,WAAW,cAAc;AAC/B,SAAO,iBAAiB,UAAU,qBAAqB,UAAU,KAAK;AACvE;AAHgB;AAKT,SAAS,sBAAsB,OAAoC;AACzE,QAAM,WAAW,eAAe;AAChC,SAAO,iBAAiB,iBAAiB,4BAA4B,UAAU,KAAK;AACrF;AAHgB;AAKT,SAAS,kBAAkB,OAAoC;AACrE,QAAM,WAAW,cAAc;AAC/B,SAAO,iBAAiB,aAAa,wBAAwB,UAAU,KAAK;AAC7E;AAHgB;AAKT,SAAS,yBAAyB,OAAoC;AAC5E,QAAM,WAAW,eAAe;AAChC,SAAO,iBAAiB,oBAAoB,+BAA+B,UAAU,KAAK;AAC3F;AAHgB;AAKT,SAAS,YAAY,OAAoC;AAC/D,QAAM,WAAW,gBAAgB;AACjC,SAAO,iBAAiB,OAAO,kBAAkB,UAAU,KAAK;AACjE;AAHgB;AAKT,SAAS,eAAe,OAAoC;AAClE,QAAM,WAAW,gBAAgB;AACjC,SAAO,iBAAiB,UAAU,qBAAqB,UAAU,KAAK;AACvE;AAHgB;AAKT,SAAS,kBAAkB,SAAsC;AACvE,QAAM,WAAW,cAAc;AAC/B,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,aAAO,QAAQ,YAAY,KACxB,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,wBAAwB,2BAA2B,OAAO,QAAQ,CAAC;AAAA,IAC9G;AAAA,EACD;AACD;AATgB;;;ACxCT,IAAM,kBAAN,cAAgD,cAAiB;AAAA,EAChE,SAAS,QAAsB;AACrC,WAAO,KAAK,cAAc,eAAe,MAAM,CAAmB;AAAA,EACnE;AAAA,EAEO,gBAAgB,QAAsB;AAC5C,WAAO,KAAK,cAAc,sBAAsB,MAAM,CAAmB;AAAA,EAC1E;AAAA,EAEO,YAAY,QAAsB;AACxC,WAAO,KAAK,cAAc,kBAAkB,MAAM,CAAmB;AAAA,EACtE;AAAA,EAEO,mBAAmB,QAAsB;AAC/C,WAAO,KAAK,cAAc,yBAAyB,MAAM,CAAmB;AAAA,EAC7E;AAAA,EAEO,MAAwB,QAA+B;AAC7D,WAAO,KAAK,cAAc,YAAY,MAAM,CAAmB;AAAA,EAChE;AAAA,EAEO,SAAS,QAAsB;AACrC,WAAO,KAAK,cAAc,eAAe,MAAM,CAAmB;AAAA,EACnE;AAAA,EAEA,IAAW,WAAiB;AAC3B,WAAO,KAAK,mBAAmB,EAAE;AAAA,EAClC;AAAA,EAEA,IAAW,WAAiB;AAC3B,WAAO,KAAK,SAAS,EAAE;AAAA,EACxB;AAAA,EAEO,YAAY,QAAsB;AACxC,WAAO,KAAK,cAAc,kBAAkB,MAAM,CAAmB;AAAA,EACtE;AAAA,EAEA,IAAW,MAAY;AACtB,WAAO,KAAK,UAAU,CAAC,UAAW,QAAQ,IAAI,CAAC,QAAQ,KAAW;AAAA,EACnE;AAAA,EAEO,KAAK,MAAoB;AAC/B,WAAO,KAAK,UAAU,CAAC,UAAU,OAAO,OAAO,MAAM,KAAK,CAAM;AAAA,EACjE;AAAA,EAEO,MAAM,MAAoB;AAChC,WAAO,KAAK,UAAU,CAAC,UAAU,OAAO,QAAQ,MAAM,KAAK,CAAM;AAAA,EAClE;AAAA,EAEU,OAAO,OAA4C;AAC5D,WAAO,OAAO,UAAU,WACrB,OAAO,GAAG,KAAU,IACpB,OAAO,IAAI,IAAI,gBAAgB,YAAY,+BAA+B,KAAK,CAAC;AAAA,EACpF;AACD;AAtDa;;;ACRN,IAAM,cAA0C;AAAA,EACtD,IAAI,OAAgB;AACnB,WAAO,QACJ,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,kBAAkB,yBAAyB,OAAO,MAAM,CAAC;AAAA,EACpG;AACD;AAEO,IAAM,eAA4C;AAAA,EACxD,IAAI,OAAgB;AACnB,WAAO,QACJ,OAAO,IAAI,IAAI,wBAAwB,mBAAmB,yBAAyB,OAAO,OAAO,CAAC,IAClG,OAAO,GAAG,KAAK;AAAA,EACnB;AACD;;;ACdO,IAAM,mBAAN,cAA4D,cAAiB;AAAA,EACnF,IAAW,OAA+B;AACzC,WAAO,KAAK,cAAc,WAA6B;AAAA,EACxD;AAAA,EAEA,IAAW,QAAiC;AAC3C,WAAO,KAAK,cAAc,YAA8B;AAAA,EACzD;AAAA,EAEO,MAA8B,OAA+B;AACnE,WAAQ,QAAQ,KAAK,OAAO,KAAK;AAAA,EAClC;AAAA,EAEO,SAAiC,OAA+B;AACtE,WAAQ,QAAQ,KAAK,QAAQ,KAAK;AAAA,EACnC;AAAA,EAEU,OAAO,OAA4C;AAC5D,WAAO,OAAO,UAAU,YACrB,OAAO,GAAG,KAAU,IACpB,OAAO,IAAI,IAAI,gBAAgB,aAAa,gCAAgC,KAAK,CAAC;AAAA,EACtF;AACD;AAtBa;;;ACSb,SAAS,eAAe,YAAwB,MAA0B,UAAkB,QAAmC;AAC9H,SAAO;AAAA,IACN,IAAI,OAAa;AAChB,aAAO,WAAW,MAAM,QAAQ,GAAG,MAAM,IACtC,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,MAAM,sBAAsB,OAAO,QAAQ,CAAC;AAAA,IACvF;AAAA,EACD;AACD;AARS;AAUF,SAAS,aAAa,OAAgC;AAC5D,QAAM,WAAW,cAAc,MAAM,YAAY;AACjD,SAAO,eAAe,UAAU,mBAAmB,UAAU,MAAM,QAAQ,CAAC;AAC7E;AAHgB;AAKT,SAAS,oBAAoB,OAAgC;AACnE,QAAM,WAAW,eAAe,MAAM,YAAY;AAClD,SAAO,eAAe,iBAAiB,0BAA0B,UAAU,MAAM,QAAQ,CAAC;AAC3F;AAHgB;AAKT,SAAS,gBAAgB,OAAgC;AAC/D,QAAM,WAAW,cAAc,MAAM,YAAY;AACjD,SAAO,eAAe,aAAa,sBAAsB,UAAU,MAAM,QAAQ,CAAC;AACnF;AAHgB;AAKT,SAAS,uBAAuB,OAAgC;AACtE,QAAM,WAAW,eAAe,MAAM,YAAY;AAClD,SAAO,eAAe,oBAAoB,6BAA6B,UAAU,MAAM,QAAQ,CAAC;AACjG;AAHgB;AAKT,SAAS,UAAU,OAAgC;AACzD,QAAM,WAAW,gBAAgB,MAAM,YAAY;AACnD,SAAO,eAAe,OAAO,gBAAgB,UAAU,MAAM,QAAQ,CAAC;AACvE;AAHgB;AAKT,SAAS,aAAa,OAAgC;AAC5D,QAAM,WAAW,gBAAgB,MAAM,YAAY;AACnD,SAAO,eAAe,UAAU,mBAAmB,UAAU,MAAM,QAAQ,CAAC;AAC7E;AAHgB;AAKT,IAAM,cAAiC;AAAA,EAC7C,IAAI,OAAa;AAChB,WAAO,OAAO,MAAM,MAAM,QAAQ,CAAC,IAChC,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,kBAAkB,sBAAsB,OAAO,kBAAkB,CAAC;AAAA,EAC7G;AACD;AAEO,IAAM,YAA+B;AAAA,EAC3C,IAAI,OAAa;AAChB,WAAO,OAAO,MAAM,MAAM,QAAQ,CAAC,IAChC,OAAO,IAAI,IAAI,wBAAwB,gBAAgB,sBAAsB,OAAO,kBAAkB,CAAC,IACvG,OAAO,GAAG,KAAK;AAAA,EACnB;AACD;;;ACvDO,IAAM,gBAAN,cAA4B,cAAoB;AAAA,EAC/C,SAAS,MAAoC;AACnD,WAAO,KAAK,cAAc,aAAa,IAAI,KAAK,IAAI,CAAC,CAAC;AAAA,EACvD;AAAA,EAEO,gBAAgB,MAAoC;AAC1D,WAAO,KAAK,cAAc,oBAAoB,IAAI,KAAK,IAAI,CAAC,CAAC;AAAA,EAC9D;AAAA,EAEO,YAAY,MAAoC;AACtD,WAAO,KAAK,cAAc,gBAAgB,IAAI,KAAK,IAAI,CAAC,CAAC;AAAA,EAC1D;AAAA,EAEO,mBAAmB,MAAoC;AAC7D,WAAO,KAAK,cAAc,uBAAuB,IAAI,KAAK,IAAI,CAAC,CAAC;AAAA,EACjE;AAAA,EAEO,MAAM,MAAoC;AAChD,UAAM,WAAW,IAAI,KAAK,IAAI;AAC9B,WAAO,OAAO,MAAM,SAAS,QAAQ,CAAC,IACnC,KAAK,UACL,KAAK,cAAc,UAAU,QAAQ,CAAC;AAAA,EAC1C;AAAA,EAEO,SAAS,MAAoC;AACnD,UAAM,WAAW,IAAI,KAAK,IAAI;AAC9B,WAAO,OAAO,MAAM,SAAS,QAAQ,CAAC,IACnC,KAAK,QACL,KAAK,cAAc,aAAa,QAAQ,CAAC;AAAA,EAC7C;AAAA,EAEA,IAAW,QAAc;AACxB,WAAO,KAAK,cAAc,SAAS;AAAA,EACpC;AAAA,EAEA,IAAW,UAAgB;AAC1B,WAAO,KAAK,cAAc,WAAW;AAAA,EACtC;AAAA,EAEU,OAAO,OAA+C;AAC/D,WAAO,iBAAiB,OACrB,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,gBAAgB,UAAU,mBAAmB,KAAK,CAAC;AAAA,EACtE;AACD;AA5Ca;;;ACdb,SAAS,WAAAA,gBAA4C;AAI9C,IAAM,0BAAN,cAAyC,gBAAgB;AAAA,EAGxD,YAAY,WAAmB,SAAiB,OAAgB,UAAa;AACnF,UAAM,WAAW,SAAS,KAAK;AAC/B,SAAK,WAAW;AAAA,EACjB;AAAA,EAEgB,SAAS;AACxB,WAAO;AAAA,MACN,MAAM,KAAK;AAAA,MACX,WAAW,KAAK;AAAA,MAChB,OAAO,KAAK;AAAA,MACZ,UAAU,KAAK;AAAA,IAChB;AAAA,EACD;AAAA,EAEA,CAAW,4BAA4B,EAAE,OAAe,SAAyC;AAChG,UAAM,YAAY,QAAQ,QAAQ,KAAK,WAAW,QAAQ;AAC1D,QAAI,QAAQ,GAAG;AACd,aAAO,QAAQ,QAAQ,6BAA6B,cAAc,SAAS;AAAA,IAC5E;AAEA,UAAM,aAAa,EAAE,GAAG,SAAS,OAAO,QAAQ,UAAU,OAAO,OAAO,QAAQ,QAAS,EAAE;AAE3F,UAAM,UAAU;AAAA,IAAO,QAAQ,QAAQ,KAAK,WAAW;AACvD,UAAM,WAAWA,SAAQ,KAAK,UAAU,UAAU,EAAE,QAAQ,OAAO,OAAO;AAC1E,UAAM,QAAQA,SAAQ,KAAK,OAAO,UAAU,EAAE,QAAQ,OAAO,OAAO;AAEpE,UAAM,SAAS,GAAG,QAAQ,QAAQ,2BAA2B,SAAS,OAAO;AAC7E,UAAM,UAAU,QAAQ,QAAQ,KAAK,SAAS,QAAQ;AACtD,UAAM,gBAAgB;AAAA,IAAO,QAAQ,QAAQ,aAAa,QAAQ,IAAI,UAAU;AAChF,UAAM,aAAa;AAAA,IAAO,QAAQ,QAAQ,aAAa,QAAQ,IAAI,UAAU;AAC7E,WAAO,GAAG;AAAA,IAAa;AAAA,EAAY;AAAA,EAAkB;AAAA,EACtD;AACD;AAnCa;;;ACEN,IAAM,oBAAN,cAAmC,cAAiB;AAAA,EAGnD,YAAY,UAA0B,cAAyC,CAAC,GAAG;AACzF,UAAM,WAAW;AACjB,SAAK,WAAW;AAAA,EACjB;AAAA,EAEU,OAAO,OAAoE;AACpF,WAAO,iBAAiB,KAAK,WAC1B,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,iBAAiB,YAAY,OAAO,KAAK,QAAQ,CAAC;AAAA,EAC7F;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,UAAU,KAAK,WAAW,CAAC;AAAA,EAC7E;AACD;AAjBa;;;ACDN,IAAM,mBAAN,cAAkC,cAAiB;AAAA,EAGlD,YAAY,SAAY,cAAyC,CAAC,GAAG;AAC3E,UAAM,WAAW;AACjB,SAAK,WAAW;AAAA,EACjB;AAAA,EAEU,OAAO,OAAuD;AACvE,WAAO,OAAO,GAAG,OAAO,KAAK,QAAQ,IAClC,OAAO,GAAG,KAAU,IACpB,OAAO,IAAI,IAAI,wBAAwB,gBAAgB,gCAAgC,OAAO,KAAK,QAAQ,CAAC;AAAA,EAChH;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,UAAU,KAAK,WAAW,CAAC;AAAA,EAC7E;AACD;AAjBa;;;ACDN,IAAM,iBAAN,cAA6B,cAAqB;AAAA,EAC9C,OAAO,OAAgD;AAChE,WAAO,OAAO,IAAI,IAAI,gBAAgB,WAAW,qCAAqC,KAAK,CAAC;AAAA,EAC7F;AACD;AAJa;;;ACAN,IAAM,mBAAN,cAA+B,cAAgC;AAAA,EAC3D,OAAO,OAA2D;AAC3E,WAAO,UAAU,UAAa,UAAU,OACrC,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,gBAAgB,aAAa,8BAA8B,KAAK,CAAC;AAAA,EACpF;AACD;AANa;;;ACeb,SAAS,iBAAiB,YAAwB,MAA4B,UAAkB,QAAqC;AACpI,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,aAAO,WAAW,OAAO,MAAM,IAC5B,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,MAAM,wBAAwB,OAAO,QAAQ,CAAC;AAAA,IACzF;AAAA,EACD;AACD;AARS;AAUF,SAAS,eAAe,OAAoC;AAClE,QAAM,WAAW,cAAc;AAC/B,SAAO,iBAAiB,UAAU,qBAAqB,UAAU,KAAK;AACvE;AAHgB;AAKT,SAAS,sBAAsB,OAAoC;AACzE,QAAM,WAAW,eAAe;AAChC,SAAO,iBAAiB,iBAAiB,4BAA4B,UAAU,KAAK;AACrF;AAHgB;AAKT,SAAS,kBAAkB,OAAoC;AACrE,QAAM,WAAW,cAAc;AAC/B,SAAO,iBAAiB,aAAa,wBAAwB,UAAU,KAAK;AAC7E;AAHgB;AAKT,SAAS,yBAAyB,OAAoC;AAC5E,QAAM,WAAW,eAAe;AAChC,SAAO,iBAAiB,oBAAoB,+BAA+B,UAAU,KAAK;AAC3F;AAHgB;AAKT,SAAS,YAAY,OAAoC;AAC/D,QAAM,WAAW,gBAAgB;AACjC,SAAO,iBAAiB,OAAO,kBAAkB,UAAU,KAAK;AACjE;AAHgB;AAKT,SAAS,eAAe,OAAoC;AAClE,QAAM,WAAW,gBAAgB;AACjC,SAAO,iBAAiB,UAAU,qBAAqB,UAAU,KAAK;AACvE;AAHgB;AAKT,IAAM,YAAiC;AAAA,EAC7C,IAAI,OAAe;AAClB,WAAO,OAAO,UAAU,KAAK,IAC1B,OAAO,GAAG,KAAK,IACf,OAAO;AAAA,MACP,IAAI,wBAAwB,gBAAgB,iCAAiC,OAAO,uCAAuC;AAAA,IAC3H;AAAA,EACJ;AACD;AAEO,IAAM,gBAAqC;AAAA,EACjD,IAAI,OAAe;AAClB,WAAO,OAAO,cAAc,KAAK,IAC9B,OAAO,GAAG,KAAK,IACf,OAAO;AAAA,MACP,IAAI;AAAA,QACH;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACD;AAAA,IACA;AAAA,EACJ;AACD;AAEO,IAAM,eAAoC;AAAA,EAChD,IAAI,OAAe;AAClB,WAAO,OAAO,SAAS,KAAK,IACzB,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,mBAAmB,6BAA6B,OAAO,sCAAsC,CAAC;AAAA,EACzI;AACD;AAEO,IAAM,YAAiC;AAAA,EAC7C,IAAI,OAAe;AAClB,WAAO,OAAO,MAAM,KAAK,IACtB,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,uBAAuB,wBAAwB,OAAO,kBAAkB,CAAC;AAAA,EACpH;AACD;AAEO,IAAM,eAAoC;AAAA,EAChD,IAAI,OAAe;AAClB,WAAO,OAAO,MAAM,KAAK,IACtB,OAAO,IAAI,IAAI,wBAAwB,0BAA0B,wBAAwB,OAAO,kBAAkB,CAAC,IACnH,OAAO,GAAG,KAAK;AAAA,EACnB;AACD;AAEO,SAAS,kBAAkB,SAAsC;AACvE,QAAM,WAAW,cAAc;AAC/B,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,aAAO,QAAQ,YAAY,IACxB,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,wBAAwB,2BAA2B,OAAO,QAAQ,CAAC;AAAA,IAC9G;AAAA,EACD;AACD;AATgB;;;ACzFT,IAAM,kBAAN,cAAgD,cAAiB;AAAA,EAChE,SAAS,QAAsB;AACrC,WAAO,KAAK,cAAc,eAAe,MAAM,CAAmB;AAAA,EACnE;AAAA,EAEO,gBAAgB,QAAsB;AAC5C,WAAO,KAAK,cAAc,sBAAsB,MAAM,CAAmB;AAAA,EAC1E;AAAA,EAEO,YAAY,QAAsB;AACxC,WAAO,KAAK,cAAc,kBAAkB,MAAM,CAAmB;AAAA,EACtE;AAAA,EAEO,mBAAmB,QAAsB;AAC/C,WAAO,KAAK,cAAc,yBAAyB,MAAM,CAAmB;AAAA,EAC7E;AAAA,EAEO,MAAwB,QAA+B;AAC7D,WAAO,OAAO,MAAM,MAAM,IACtB,KAAK,cAAc,SAA2B,IAC9C,KAAK,cAAc,YAAY,MAAM,CAAmB;AAAA,EAC7D;AAAA,EAEO,SAAS,QAAsB;AACrC,WAAO,OAAO,MAAM,MAAM,IACvB,KAAK,cAAc,YAA8B,IACjD,KAAK,cAAc,eAAe,MAAM,CAAmB;AAAA,EAC/D;AAAA,EAEA,IAAW,MAAY;AACtB,WAAO,KAAK,cAAc,SAA2B;AAAA,EACtD;AAAA,EAEA,IAAW,UAAgB;AAC1B,WAAO,KAAK,cAAc,aAA+B;AAAA,EAC1D;AAAA,EAEA,IAAW,SAAe;AACzB,WAAO,KAAK,cAAc,YAA8B;AAAA,EACzD;AAAA,EAEA,IAAW,WAAiB;AAC3B,WAAO,KAAK,mBAAmB,CAAC;AAAA,EACjC;AAAA,EAEA,IAAW,WAAiB;AAC3B,WAAO,KAAK,SAAS,CAAC;AAAA,EACvB;AAAA,EAEO,YAAY,SAAuB;AACzC,WAAO,KAAK,cAAc,kBAAkB,OAAO,CAAmB;AAAA,EACvE;AAAA,EAEA,IAAW,MAAY;AACtB,WAAO,KAAK,UAAU,KAAK,GAA2B;AAAA,EACvD;AAAA,EAEA,IAAW,OAAa;AACvB,WAAO,KAAK,UAAU,KAAK,IAA4B;AAAA,EACxD;AAAA,EAEA,IAAW,QAAc;AACxB,WAAO,KAAK,UAAU,KAAK,KAA6B;AAAA,EACzD;AAAA,EAEA,IAAW,QAAc;AACxB,WAAO,KAAK,UAAU,KAAK,KAA6B;AAAA,EACzD;AAAA,EAEA,IAAW,SAAe;AACzB,WAAO,KAAK,UAAU,KAAK,MAA8B;AAAA,EAC1D;AAAA,EAEA,IAAW,QAAc;AACxB,WAAO,KAAK,UAAU,KAAK,KAA6B;AAAA,EACzD;AAAA,EAEA,IAAW,OAAa;AACvB,WAAO,KAAK,UAAU,KAAK,IAA4B;AAAA,EACxD;AAAA,EAEU,OAAO,OAA4C;AAC5D,WAAO,OAAO,UAAU,WACrB,OAAO,GAAG,KAAU,IACpB,OAAO,IAAI,IAAI,gBAAgB,YAAY,+BAA+B,KAAK,CAAC;AAAA,EACpF;AACD;AAtFa;;;AChBN,IAAM,uBAAN,cAAmC,UAAU;AAAA,EAG5C,YAAY,UAAuB;AACzC,UAAM,gCAAgC;AACtC,SAAK,WAAW;AAAA,EACjB;AAAA,EAEO,SAAS;AACf,WAAO;AAAA,MACN,MAAM,KAAK;AAAA,MACX,UAAU,KAAK;AAAA,IAChB;AAAA,EACD;AAAA,EAEA,CAAW,4BAA4B,EAAE,OAAe,SAAyC;AAChG,UAAM,WAAW,QAAQ,QAAQ,KAAK,SAAS,SAAS,GAAG,QAAQ;AACnE,QAAI,QAAQ,GAAG;AACd,aAAO,QAAQ,QAAQ,0BAA0B,aAAa,SAAS;AAAA,IACxE;AAEA,UAAM,SAAS,GAAG,QAAQ,QAAQ,wBAAwB,SAAS,OAAO;AAC1E,UAAM,UAAU,QAAQ,QAAQ,KAAK,SAAS,QAAQ;AACtD,WAAO,GAAG;AAAA,IAAa;AAAA,EACxB;AACD;AAzBa;;;ACHb,SAAS,WAAAA,gBAA4C;AAG9C,IAAM,uBAAN,cAAmC,UAAU;AAAA,EAI5C,YAAY,UAAuB,OAAgB;AACzD,UAAM,8BAA8B;AAEpC,SAAK,WAAW;AAChB,SAAK,QAAQ;AAAA,EACd;AAAA,EAEO,SAAS;AACf,WAAO;AAAA,MACN,MAAM,KAAK;AAAA,MACX,UAAU,KAAK;AAAA,MACf,OAAO,KAAK;AAAA,IACb;AAAA,EACD;AAAA,EAEA,CAAW,4BAA4B,EAAE,OAAe,SAAyC;AAChG,UAAM,WAAW,QAAQ,QAAQ,KAAK,SAAS,SAAS,GAAG,QAAQ;AACnE,QAAI,QAAQ,GAAG;AACd,aAAO,QAAQ,QAAQ,0BAA0B,aAAa,SAAS;AAAA,IACxE;AAEA,UAAM,aAAa,EAAE,GAAG,SAAS,OAAO,QAAQ,UAAU,OAAO,OAAO,QAAQ,QAAS,GAAG,SAAS,KAAK;AAE1G,UAAM,UAAU;AAAA,IAAO,QAAQ,QAAQ,KAAK,WAAW;AACvD,UAAM,QAAQA,SAAQ,KAAK,OAAO,UAAU,EAAE,QAAQ,OAAO,OAAO;AAEpE,UAAM,SAAS,GAAG,QAAQ,QAAQ,wBAAwB,SAAS,OAAO;AAC1E,UAAM,UAAU,QAAQ,QAAQ,KAAK,SAAS,QAAQ;AACtD,UAAM,aAAa;AAAA,IAAO,QAAQ,QAAQ,aAAa,QAAQ,IAAI,UAAU;AAC7E,WAAO,GAAG;AAAA,IAAa;AAAA,EAAY;AAAA,EACpC;AACD;AAnCa;;;ACGN,IAAM,mBAAN,cAAkC,cAAiB;AAAA,EAIlD,YAAY,WAA6B,OAAsB,cAAyC,CAAC,GAAG;AAClH,UAAM,WAAW;AACjB,SAAK,YAAY;AACjB,SAAK,eAAe;AAAA,EACrB;AAAA,EAEgB,QAAQ,OAAuG;AAC9H,UAAM,QAAQ,KAAK,MAAM;AACzB,UAAM,eAAe;AACrB,WAAO;AAAA,EACR;AAAA,EAEU,OAAO,OAA2C;AAC3D,WAAO,OAAO,UAAU,cACrB,OAAO,GAAG,SAAS,KAAK,YAAY,CAAC,IACrC,KAAK,UAAU,QAAQ,EAAE,KAAK;AAAA,EAClC;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,WAAW,KAAK,cAAc,KAAK,WAAW,CAAC;AAAA,EACjG;AACD;AAzBa;;;ACHN,IAAM,gBAAN,cAA4B,UAAU;AAAA,EAGrC,YAAY,QAA8B;AAChD,UAAM,6BAA6B;AAEnC,SAAK,SAAS;AAAA,EACf;AAAA,EAEA,CAAW,4BAA4B,EAAE,OAAe,SAAyC;AAChG,QAAI,QAAQ,GAAG;AACd,aAAO,QAAQ,QAAQ,mBAAmB,SAAS;AAAA,IACpD;AAEA,UAAM,aAAa,EAAE,GAAG,SAAS,OAAO,QAAQ,UAAU,OAAO,OAAO,QAAQ,QAAS,GAAG,SAAS,KAAK;AAE1G,UAAM,UAAU;AAAA,IAAO,QAAQ,QAAQ,KAAK,WAAW;AAEvD,UAAM,SAAS,GAAG,QAAQ,QAAQ,iBAAiB,SAAS,MAAM,QAAQ,QAAQ,KAAK,OAAO,OAAO,SAAS,GAAG,QAAQ;AACzH,UAAM,UAAU,QAAQ,QAAQ,KAAK,SAAS,QAAQ;AACtD,UAAM,SAAS,KAAK,OAClB,IAAI,CAAC,OAAO,MAAM;AAClB,YAAM,QAAQ,QAAQ,SAAS,IAAI,GAAG,SAAS,GAAG,QAAQ;AAC1D,YAAM,OAAO,MAAM,4BAA4B,EAAE,QAAQ,GAAG,UAAU,EAAE,QAAQ,OAAO,OAAO;AAE9F,aAAO,KAAK,SAAS;AAAA,IACtB,CAAC,EACA,KAAK,MAAM;AACb,WAAO,GAAG;AAAA,IAAa;AAAA;AAAA,EAAc;AAAA,EACtC;AACD;AA9Ba;;;ACIN,IAAM,iBAAN,cAAgC,cAAiB;AAAA,EAGhD,YAAY,YAAyC,cAAyC,CAAC,GAAG;AACxG,UAAM,WAAW;AACjB,SAAK,aAAa;AAAA,EACnB;AAAA,EAEA,IAAoB,WAA0C;AAC7D,QAAI,KAAK,WAAW,WAAW;AAAG,aAAO,IAAI,eAA8B,CAAC,IAAI,iBAAiB,MAAS,CAAC,GAAG,KAAK,WAAW;AAE9H,UAAM,CAAC,SAAS,IAAI,KAAK;AACzB,QAAI,qBAAqB,kBAAkB;AAE1C,UAAI,UAAU,aAAa;AAAW,eAAO,KAAK,MAAM;AAGxD,UAAI,UAAU,aAAa,MAAM;AAChC,eAAO,IAAI;AAAA,UACV,CAAC,IAAI,iBAAiB,GAAG,GAAG,KAAK,WAAW,MAAM,CAAC,CAAC;AAAA,UACpD,KAAK;AAAA,QACN;AAAA,MACD;AAAA,IACD,WAAW,qBAAqB,kBAAkB;AAEjD,aAAO,KAAK,MAAM;AAAA,IACnB;AAEA,WAAO,IAAI,eAAe,CAAC,IAAI,iBAAiB,MAAS,GAAG,GAAG,KAAK,UAAU,CAAC;AAAA,EAChF;AAAA,EAEA,IAAW,WAAkD;AAG5D,QAAI,KAAK,WAAW,WAAW;AAAG,aAAO,KAAK,MAAM;AAEpD,UAAM,CAAC,SAAS,IAAI,KAAK;AACzB,QAAI,qBAAqB,kBAAkB;AAC1C,UAAI,UAAU,aAAa;AAAW,eAAO,IAAI,eAAe,KAAK,WAAW,MAAM,CAAC,GAAG,KAAK,WAAW;AAAA,IAC3G,WAAW,qBAAqB,kBAAkB;AACjD,aAAO,IAAI,eAAe,CAAC,IAAI,iBAAiB,IAAI,GAAG,GAAG,KAAK,WAAW,MAAM,CAAC,CAAC,GAAG,KAAK,WAAW;AAAA,IACtG;AAEA,WAAO,KAAK,MAAM;AAAA,EACnB;AAAA,EAEA,IAAoB,WAAqC;AACxD,QAAI,KAAK,WAAW,WAAW;AAAG,aAAO,IAAI,eAAyB,CAAC,IAAI,iBAAiB,IAAI,CAAC,GAAG,KAAK,WAAW;AAEpH,UAAM,CAAC,SAAS,IAAI,KAAK;AACzB,QAAI,qBAAqB,kBAAkB;AAE1C,UAAI,UAAU,aAAa;AAAM,eAAO,KAAK,MAAM;AAGnD,UAAI,UAAU,aAAa,QAAW;AACrC,eAAO,IAAI;AAAA,UACV,CAAC,IAAI,iBAAiB,GAAG,GAAG,KAAK,WAAW,MAAM,CAAC,CAAC;AAAA,UACpD,KAAK;AAAA,QACN;AAAA,MACD;AAAA,IACD,WAAW,qBAAqB,kBAAkB;AAEjD,aAAO,KAAK,MAAM;AAAA,IACnB;AAEA,WAAO,IAAI,eAAe,CAAC,IAAI,iBAAiB,IAAI,GAAG,GAAG,KAAK,UAAU,CAAC;AAAA,EAC3E;AAAA,EAEA,IAAoB,UAAgD;AACnE,QAAI,KAAK,WAAW,WAAW;AAAG,aAAO,IAAI,eAAqC,CAAC,IAAI,iBAAiB,CAAC,GAAG,KAAK,WAAW;AAE5H,UAAM,CAAC,SAAS,IAAI,KAAK;AACzB,QAAI,qBAAqB,kBAAkB;AAE1C,UAAI,UAAU,aAAa,QAAQ,UAAU,aAAa,QAAW;AACpE,eAAO,IAAI,eAAqC,CAAC,IAAI,iBAAiB,GAAG,GAAG,KAAK,WAAW,MAAM,CAAC,CAAC,GAAG,KAAK,WAAW;AAAA,MACxH;AAAA,IACD,WAAW,qBAAqB,kBAAkB;AAEjD,aAAO,KAAK,MAAM;AAAA,IACnB;AAEA,WAAO,IAAI,eAAqC,CAAC,IAAI,iBAAiB,GAAG,GAAG,KAAK,UAAU,CAAC;AAAA,EAC7F;AAAA,EAEgB,MAAS,YAAgE;AACxF,WAAO,IAAI,eAAsB,CAAC,GAAG,KAAK,YAAY,GAAG,UAAU,CAAC;AAAA,EACrE;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,YAAY,KAAK,WAAW,CAAC;AAAA,EAC/E;AAAA,EAEU,OAAO,OAA4D;AAC5E,UAAM,SAAsB,CAAC;AAE7B,eAAW,aAAa,KAAK,YAAY;AACxC,YAAM,SAAS,UAAU,IAAI,KAAK;AAClC,UAAI,OAAO,KAAK;AAAG,eAAO;AAC1B,aAAO,KAAK,OAAO,KAAM;AAAA,IAC1B;AAEA,WAAO,OAAO,IAAI,IAAI,cAAc,MAAM,CAAC;AAAA,EAC5C;AACD;AAzGa;;;ACON,IAAM,kBAAN,cAA4E,cAAiB;AAAA,EAU5F,YACN,OACA,WAAoC,gBACpC,cAAyC,CAAC,GACzC;AACD,UAAM,WAAW;AAZlB,SAAiB,OAA6B,CAAC;AAG/C,SAAiB,eAAe,oBAAI,IAAqC;AACzE,SAAiB,wBAAwB,oBAAI,IAAqC;AAClF,SAAiB,oCAAoC,oBAAI,IAAwC;AAQhG,SAAK,QAAQ;AACb,SAAK,WAAW;AAEhB,YAAQ,KAAK,UAAU;AAAA,MACtB,KAAK;AACJ,aAAK,iBAAiB,CAAC,UAAU,KAAK,qBAAqB,KAAK;AAChE;AAAA,MACD,KAAK,gBAAgC;AACpC,aAAK,iBAAiB,CAAC,UAAU,KAAK,qBAAqB,KAAK;AAChE;AAAA,MACD;AAAA,MACA,KAAK;AACJ,aAAK,iBAAiB,CAAC,UAAU,KAAK,0BAA0B,KAAK;AACrE;AAAA,IACF;AAEA,UAAM,eAAe,OAAO,QAAQ,KAAK;AACzC,SAAK,OAAO,aAAa,IAAI,CAAC,CAAC,GAAG,MAAM,GAAG;AAE3C,eAAW,CAAC,KAAK,SAAS,KAAK,cAAc;AAC5C,UAAI,qBAAqB,gBAAgB;AAExC,cAAM,CAAC,iCAAiC,IAAI,UAAU,YAAY;AAElE,YAAI,6CAA6C,kBAAkB;AAClE,eAAK,sBAAsB,IAAI,KAAK,SAAS;AAAA,QAC9C,WAAW,6CAA6C,kBAAkB;AACzE,cAAI,kCAAkC,aAAa,QAAW;AAC7D,iBAAK,sBAAsB,IAAI,KAAK,SAAS;AAAA,UAC9C,OAAO;AACN,iBAAK,aAAa,IAAI,KAAK,SAAS;AAAA,UACrC;AAAA,QACD,WAAW,qBAAqB,kBAAkB;AACjD,eAAK,kCAAkC,IAAI,KAAK,SAAS;AAAA,QAC1D,OAAO;AACN,eAAK,aAAa,IAAI,KAAK,SAAS;AAAA,QACrC;AAAA,MACD,WAAW,qBAAqB,kBAAkB;AACjD,aAAK,sBAAsB,IAAI,KAAK,SAAS;AAAA,MAC9C,WAAW,qBAAqB,kBAAkB;AACjD,YAAI,UAAU,aAAa,QAAW;AACrC,eAAK,sBAAsB,IAAI,KAAK,SAAS;AAAA,QAC9C,OAAO;AACN,eAAK,aAAa,IAAI,KAAK,SAAS;AAAA,QACrC;AAAA,MACD,WAAW,qBAAqB,kBAAkB;AACjD,aAAK,kCAAkC,IAAI,KAAK,SAAS;AAAA,MAC1D,OAAO;AACN,aAAK,aAAa,IAAI,KAAK,SAAS;AAAA,MACrC;AAAA,IACD;AAAA,EACD;AAAA,EAEA,IAAW,SAAe;AACzB,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,OAAO,gBAAgC,KAAK,WAAW,CAAC;AAAA,EAC1G;AAAA,EAEA,IAAW,SAAe;AACzB,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,OAAO,gBAAgC,KAAK,WAAW,CAAC;AAAA,EAC1G;AAAA,EAEA,IAAW,cAAoB;AAC9B,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,OAAO,qBAAqC,KAAK,WAAW,CAAC;AAAA,EAC/G;AAAA,EAEA,IAAW,UAA0D;AACpE,UAAM,QAAQ,OAAO,YAAY,KAAK,KAAK,IAAI,CAAC,QAAQ,CAAC,KAAK,KAAK,MAAM,GAAyC,EAAE,QAAQ,CAAC,CAAC;AAC9H,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,OAAO,KAAK,UAAU,KAAK,WAAW,CAAC;AAAA,EACpF;AAAA,EAEA,IAAW,WAA4D;AACtE,UAAM,QAAQ,OAAO;AAAA,MACpB,KAAK,KAAK,IAAI,CAAC,QAAQ;AACtB,YAAI,YAAY,KAAK,MAAM,GAAyC;AACpE,YAAI,qBAAqB;AAAgB,sBAAY,UAAU;AAC/D,eAAO,CAAC,KAAK,SAAS;AAAA,MACvB,CAAC;AAAA,IACF;AACA,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,OAAO,KAAK,UAAU,KAAK,WAAW,CAAC;AAAA,EACpF;AAAA,EAEO,OAA0B,QAAkF;AAClH,UAAM,QAAQ,EAAE,GAAG,KAAK,OAAO,GAAI,kBAAkB,kBAAkB,OAAO,QAAQ,OAAQ;AAC9F,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,OAAO,KAAK,UAAU,KAAK,WAAW,CAAC;AAAA,EACpF;AAAA,EAEO,KAAwB,MAA4E;AAC1G,UAAM,QAAQ,OAAO;AAAA,MACpB,KAAK,OAAO,CAAC,QAAQ,KAAK,KAAK,SAAS,GAAG,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,KAAK,MAAM,GAAyC,CAAC,CAAC;AAAA,IACxH;AACA,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,OAAO,KAAK,UAAU,KAAK,WAAW,CAAC;AAAA,EACpF;AAAA,EAEO,KAAwB,MAA4E;AAC1G,UAAM,QAAQ,OAAO;AAAA,MACpB,KAAK,KAAK,OAAO,CAAC,QAAQ,CAAC,KAAK,SAAS,GAAU,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,KAAK,MAAM,GAAyC,CAAC,CAAC;AAAA,IAChI;AACA,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,OAAO,KAAK,UAAU,KAAK,WAAW,CAAC;AAAA,EACpF;AAAA,EAEmB,OAAO,OAAoE;AAC7F,UAAM,cAAc,OAAO;AAC3B,QAAI,gBAAgB,UAAU;AAC7B,aAAO,OAAO,IAAI,IAAI,gBAAgB,eAAe,oDAAoD,uBAAuB,KAAK,CAAC;AAAA,IACvI;AAEA,QAAI,UAAU,MAAM;AACnB,aAAO,OAAO,IAAI,IAAI,gBAAgB,eAAe,qCAAqC,KAAK,CAAC;AAAA,IACjG;AAEA,QAAI,MAAM,QAAQ,KAAK,GAAG;AACzB,aAAO,OAAO,IAAI,IAAI,gBAAgB,eAAe,yCAAyC,KAAK,CAAC;AAAA,IACrG;AAEA,QAAI,CAAC,KAAK,sBAAsB;AAC/B,aAAO,OAAO,GAAG,KAAU;AAAA,IAC5B;AAEA,eAAW,aAAa,OAAO,OAAO,KAAK,KAAK,GAA2B;AAC1E,gBAAU,UAAU,KAAK,UAAU,KAAM;AAAA,IAC1C;AAEA,WAAO,KAAK,eAAe,KAAe;AAAA,EAC3C;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,OAAO,KAAK,UAAU,KAAK,WAAW,CAAC;AAAA,EACzF;AAAA,EAEQ,qBAAqB,OAAiD;AAC7E,UAAM,SAAqC,CAAC;AAC5C,UAAM,cAAc,CAAC;AACrB,UAAM,eAAe,IAAI,IAAI,OAAO,QAAQ,KAAK,CAAyB;AAE1E,UAAM,eAAe,wBAAC,KAAc,cAAsC;AACzE,YAAM,SAAS,UAAU,IAAI,MAAM,GAAmB,CAAC;AAEvD,UAAI,OAAO,KAAK,GAAG;AAClB,oBAAY,GAAG,IAAI,OAAO;AAAA,MAC3B,OAAO;AACN,cAAM,QAAQ,OAAO;AACrB,eAAO,KAAK,CAAC,KAAK,KAAK,CAAC;AAAA,MACzB;AAAA,IACD,GATqB;AAWrB,eAAW,CAAC,KAAK,SAAS,KAAK,KAAK,cAAc;AACjD,UAAI,aAAa,OAAO,GAAG,GAAG;AAC7B,qBAAa,KAAK,SAAS;AAAA,MAC5B,OAAO;AACN,eAAO,KAAK,CAAC,KAAK,IAAI,qBAAqB,GAAG,CAAC,CAAC;AAAA,MACjD;AAAA,IACD;AAGA,eAAW,CAAC,KAAK,SAAS,KAAK,KAAK,mCAAmC;AACtE,mBAAa,OAAO,GAAG;AACvB,mBAAa,KAAK,SAAS;AAAA,IAC5B;AAGA,QAAI,aAAa,SAAS,GAAG;AAC5B,aAAO,OAAO,WAAW,IACtB,OAAO,GAAG,WAAW,IACrB,OAAO,IAAI,IAAI,sBAAsB,MAAM,CAAC;AAAA,IAChD;AAIA,UAAM,uCAAuC,KAAK,sBAAsB,OAAO,aAAa;AAE5F,QAAI,sCAAsC;AACzC,iBAAW,CAAC,GAAG,KAAK,cAAc;AACjC,cAAM,YAAY,KAAK,sBAAsB,IAAI,GAAG;AAEpD,YAAI,WAAW;AACd,uBAAa,KAAK,SAAS;AAAA,QAC5B;AAAA,MACD;AAAA,IACD,OAAO;AACN,iBAAW,CAAC,KAAK,SAAS,KAAK,KAAK,uBAAuB;AAC1D,YAAI,aAAa,OAAO,GAAG,GAAG;AAC7B,uBAAa,KAAK,SAAS;AAAA,QAC5B;AAAA,MACD;AAAA,IACD;AAEA,WAAO,OAAO,WAAW,IACtB,OAAO,GAAG,WAAW,IACrB,OAAO,IAAI,IAAI,sBAAsB,MAAM,CAAC;AAAA,EAChD;AAAA,EAEQ,qBAAqB,OAAiD;AAC7E,UAAM,SAAqC,CAAC;AAC5C,UAAM,cAAc,CAAC;AACrB,UAAM,eAAe,IAAI,IAAI,OAAO,QAAQ,KAAK,CAAyB;AAE1E,UAAM,eAAe,wBAAC,KAAc,cAAsC;AACzE,YAAM,SAAS,UAAU,IAAI,MAAM,GAAmB,CAAC;AAEvD,UAAI,OAAO,KAAK,GAAG;AAClB,oBAAY,GAAG,IAAI,OAAO;AAAA,MAC3B,OAAO;AACN,cAAM,QAAQ,OAAO;AACrB,eAAO,KAAK,CAAC,KAAK,KAAK,CAAC;AAAA,MACzB;AAAA,IACD,GATqB;AAWrB,eAAW,CAAC,KAAK,SAAS,KAAK,KAAK,cAAc;AACjD,UAAI,aAAa,OAAO,GAAG,GAAG;AAC7B,qBAAa,KAAK,SAAS;AAAA,MAC5B,OAAO;AACN,eAAO,KAAK,CAAC,KAAK,IAAI,qBAAqB,GAAG,CAAC,CAAC;AAAA,MACjD;AAAA,IACD;AAGA,eAAW,CAAC,KAAK,SAAS,KAAK,KAAK,mCAAmC;AACtE,mBAAa,OAAO,GAAG;AACvB,mBAAa,KAAK,SAAS;AAAA,IAC5B;AAEA,eAAW,CAAC,KAAK,SAAS,KAAK,KAAK,uBAAuB;AAG1D,UAAI,aAAa,SAAS,GAAG;AAC5B;AAAA,MACD;AAEA,UAAI,aAAa,OAAO,GAAG,GAAG;AAC7B,qBAAa,KAAK,SAAS;AAAA,MAC5B;AAAA,IACD;AAEA,QAAI,aAAa,SAAS,GAAG;AAC5B,iBAAW,CAAC,KAAKC,MAAK,KAAK,aAAa,QAAQ,GAAG;AAClD,eAAO,KAAK,CAAC,KAAK,IAAI,qBAAqB,KAAKA,MAAK,CAAC,CAAC;AAAA,MACxD;AAAA,IACD;AAEA,WAAO,OAAO,WAAW,IACtB,OAAO,GAAG,WAAW,IACrB,OAAO,IAAI,IAAI,sBAAsB,MAAM,CAAC;AAAA,EAChD;AAAA,EAEQ,0BAA0B,OAAiD;AAClF,UAAM,SAAS,KAAK,qBAAqB,KAAK;AAC9C,WAAO,OAAO,MAAM,IAAI,SAAS,OAAO,GAAG,EAAE,GAAG,OAAO,GAAG,OAAO,MAAM,CAAM;AAAA,EAC9E;AACD;AAxQa;;;ACVN,IAAM,uBAAN,cAA4D,cAAiB;AAAA,EACzE,OAAO,OAA4C;AAC5D,WAAO,OAAO,GAAG,KAAU;AAAA,EAC5B;AACD;AAJa;;;ACGN,IAAM,kBAAN,cAAiC,cAAiC;AAAA,EAGjE,YAAY,WAA6B,cAAyD,CAAC,GAAG;AAC5G,UAAM,WAAW;AACjB,SAAK,YAAY;AAAA,EAClB;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,WAAW,KAAK,WAAW,CAAC;AAAA,EAC9E;AAAA,EAEU,OAAO,OAAoF;AACpG,QAAI,OAAO,UAAU,UAAU;AAC9B,aAAO,OAAO,IAAI,IAAI,gBAAgB,eAAe,sBAAsB,KAAK,CAAC;AAAA,IAClF;AAEA,QAAI,UAAU,MAAM;AACnB,aAAO,OAAO,IAAI,IAAI,gBAAgB,eAAe,qCAAqC,KAAK,CAAC;AAAA,IACjG;AAEA,QAAI,MAAM,QAAQ,KAAK,GAAG;AACzB,aAAO,OAAO,IAAI,IAAI,gBAAgB,eAAe,yCAAyC,KAAK,CAAC;AAAA,IACrG;AAEA,QAAI,CAAC,KAAK,sBAAsB;AAC/B,aAAO,OAAO,GAAG,KAA0B;AAAA,IAC5C;AAEA,UAAM,SAAgC,CAAC;AACvC,UAAM,cAAiC,CAAC;AAExC,eAAW,CAAC,KAAK,GAAG,KAAK,OAAO,QAAQ,KAAM,GAAG;AAChD,YAAM,SAAS,KAAK,UAAU,IAAI,GAAG;AACrC,UAAI,OAAO,KAAK;AAAG,oBAAY,GAAG,IAAI,OAAO;AAAA;AACxC,eAAO,KAAK,CAAC,KAAK,OAAO,KAAM,CAAC;AAAA,IACtC;AAEA,WAAO,OAAO,WAAW,IACtB,OAAO,GAAG,WAAW,IACrB,OAAO,IAAI,IAAI,sBAAsB,MAAM,CAAC;AAAA,EAChD;AACD;AA1Ca;;;ACAN,IAAM,eAAN,cAA8B,cAAsB;AAAA,EAGnD,YAAY,WAA6B,cAA8C,CAAC,GAAG;AACjG,UAAM,WAAW;AACjB,SAAK,YAAY;AAAA,EAClB;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,WAAW,KAAK,WAAW,CAAC;AAAA,EAC9E;AAAA,EAEU,OAAO,QAAkE;AAClF,QAAI,EAAE,kBAAkB,MAAM;AAC7B,aAAO,OAAO,IAAI,IAAI,gBAAgB,YAAY,kBAAkB,MAAM,CAAC;AAAA,IAC5E;AAEA,QAAI,CAAC,KAAK,sBAAsB;AAC/B,aAAO,OAAO,GAAG,MAAM;AAAA,IACxB;AAEA,UAAM,SAAsB,CAAC;AAC7B,UAAM,cAAc,oBAAI,IAAO;AAE/B,eAAW,SAAS,QAAQ;AAC3B,YAAM,SAAS,KAAK,UAAU,IAAI,KAAK;AACvC,UAAI,OAAO,KAAK;AAAG,oBAAY,IAAI,OAAO,KAAK;AAAA;AAC1C,eAAO,KAAK,OAAO,KAAM;AAAA,IAC/B;AAEA,WAAO,OAAO,WAAW,IACtB,OAAO,GAAG,WAAW,IACrB,OAAO,IAAI,IAAI,cAAc,MAAM,CAAC;AAAA,EACxC;AACD;AAlCa;;;ACDb,IAAM,eACL;AAqBM,SAAS,cAAc,OAAwB;AAIrD,MAAI,CAAC;AAAO,WAAO;AAGnB,QAAM,UAAU,MAAM,QAAQ,GAAG;AAKjC,MAAI,YAAY;AAAI,WAAO;AAO3B,MAAI,UAAU;AAAI,WAAO;AAEzB,QAAM,cAAc,UAAU;AAK9B,MAAI,MAAM,SAAS,KAAK,WAAW;AAAG,WAAO;AAO7C,MAAI,MAAM,SAAS,cAAc;AAAK,WAAO;AAG7C,MAAI,WAAW,MAAM,QAAQ,KAAK,WAAW;AAM7C,MAAI,aAAa;AAAI,WAAO;AAgB5B,MAAI,eAAe;AACnB,KAAG;AACF,QAAI,WAAW,eAAe;AAAI,aAAO;AAEzC,mBAAe,WAAW;AAAA,EAC3B,UAAU,WAAW,MAAM,QAAQ,KAAK,YAAY,OAAO;AAI3D,MAAI,MAAM,SAAS,eAAe;AAAI,WAAO;AAY7C,SAAO,aAAa,KAAK,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,oBAAoB,MAAM,MAAM,WAAW,CAAC;AAClG;AAhFgB;AAkFhB,SAAS,oBAAoB,QAAyB;AACrD,MAAI;AACH,WAAO,IAAI,IAAI,UAAU,QAAQ,EAAE,aAAa;AAAA,EACjD,QAAE;AACD,WAAO;AAAA,EACR;AACD;AANS;;;ACzGT,IAAM,QAAQ;AACd,IAAM,QAAQ,IAAI,eAAe;AACjC,IAAM,UAAU,IAAI,OAAO,IAAI,QAAQ;AAGvC,IAAM,QAAQ;AACd,IAAM,UAAU,IAAI;AAAA,EACnB,QACO,gBAAgB,eAChB,gBAAgB,UAAU,eAC1B,iBAAiB,WAAW,qBAC5B,kBAAkB,eAAe,WAAW,qBAC5C,kBAAkB,eAAe,WAAW,qBAC5C,kBAAkB,eAAe,WAAW,qBAC5C,kBAAkB,eAAe,WAAW,2BACtC,eAAe,aAAa;AAE1C;AAEO,SAAS,OAAOC,IAAoB;AAC1C,SAAO,QAAQ,KAAKA,EAAC;AACtB;AAFgB;AAIT,SAAS,OAAOA,IAAoB;AAC1C,SAAO,QAAQ,KAAKA,EAAC;AACtB;AAFgB;AAIT,SAAS,KAAKA,IAAmB;AACvC,MAAI,OAAOA,EAAC;AAAG,WAAO;AACtB,MAAI,OAAOA,EAAC;AAAG,WAAO;AACtB,SAAO;AACR;AAJgB;;;AChCT,IAAM,mBAAmB;AAEzB,SAAS,oBAAoB,OAAe;AAClD,SAAO,iBAAiB,KAAK,KAAK;AACnC;AAFgB;;;ACFhB,SAAS,WAAAF,gBAA4C;AAI9C,IAAM,uCAAN,cAAgE,oBAAuB;AAAA,EAGtF,YAAY,YAAkC,SAAiB,OAAU,UAA6B;AAC5G,UAAM,YAAY,SAAS,KAAK;AAChC,SAAK,WAAW;AAAA,EACjB;AAAA,EAEO,SAAS;AACf,WAAO;AAAA,MACN,MAAM,KAAK;AAAA,MACX,YAAY,KAAK;AAAA,MACjB,OAAO,KAAK;AAAA,MACZ,UAAU,KAAK;AAAA,IAChB;AAAA,EACD;AAAA,EAEA,CAAW,4BAA4B,EAAE,OAAe,SAAyC;AAChG,UAAM,aAAa,QAAQ,QAAQ,KAAK,YAAY,QAAQ;AAC5D,QAAI,QAAQ,GAAG;AACd,aAAO,QAAQ,QAAQ,0CAA0C,eAAe,SAAS;AAAA,IAC1F;AAEA,UAAM,aAAa,EAAE,GAAG,SAAS,OAAO,QAAQ,UAAU,OAAO,OAAO,QAAQ,QAAS,EAAE;AAE3F,UAAM,eAAe,QAAQ,QAAQ,KAAK,WAAW;AACrD,UAAM,UAAU;AAAA,IAAO;AACvB,UAAM,QAAQA,SAAQ,KAAK,OAAO,UAAU,EAAE,QAAQ,OAAO,OAAO;AAEpE,UAAM,SAAS,GAAG,QAAQ,QAAQ,wCAAwC,SAAS,OAAO;AAC1F,UAAM,UAAU,QAAQ,QAAQ,KAAK,SAAS,QAAQ;AAEtD,UAAM,kBAAkB;AAAA,IAAO;AAC/B,UAAM,gBAAgB;AAAA,IAAO,QAAQ,QAAQ,kCAAkC,QAAQ,IAAI,kBAAkB,KAAK,SAChH,IAAI,CAAC,aAAa,QAAQ,QAAQ,UAAU,SAAS,CAAC,EACtD,KAAK,eAAe;AACtB,UAAM,aAAa;AAAA,IAAO,QAAQ,QAAQ,aAAa,QAAQ,IAAI,UAAU;AAC7E,WAAO,GAAG;AAAA,IAAa;AAAA,EAAY;AAAA,EAAkB;AAAA,EACtD;AACD;AAvCa;;;ACJN,SAAS,mBAAwD,KAAqC;AAC5G,UAAQ,IAAI,QAAQ;AAAA,IACnB,KAAK;AACJ,aAAO,MAAM;AAAA,IACd,KAAK;AACJ,aAAO,IAAI,CAAC;AAAA,IACb,KAAK,GAAG;AACP,YAAM,CAAC,KAAK,GAAG,IAAI;AACnB,aAAO,IAAI,WAAW,IAAI,GAAG,MAAM,KAAK,IAAI,GAAG,MAAM;AAAA,IACtD;AAAA,IACA,SAAS;AACR,aAAO,IAAI,WAAW;AACrB,mBAAW,MAAM,KAAK;AACrB,gBAAM,SAAS,GAAG,GAAG,MAAM;AAC3B,cAAI;AAAQ,mBAAO;AAAA,QACpB;AAEA,eAAO;AAAA,MACR;AAAA,IACD;AAAA,EACD;AACD;AArBgB;;;ACYT,SAAS,oBAAoB,SAAsB;AACzD,QAAM,MAA0F,CAAC;AAEjG,MAAI,SAAS,kBAAkB;AAAQ,QAAI,KAAK,mBAAmB,QAAQ,gBAAgB,CAAC;AAC5F,MAAI,SAAS,gBAAgB;AAAQ,QAAI,KAAK,iBAAiB,QAAQ,cAAc,CAAC;AAEtF,SAAO,gBAAgB,GAAG,GAAG;AAC9B;AAPgB;AAShB,SAAS,mBAAmB,kBAAoC;AAC/D,SAAO,CAAC,OAAe,QACtB,iBAAiB,SAAS,IAAI,QAA0B,IACrD,OACA,IAAI,qCAAqC,gBAAgB,wBAAwB,OAAO,gBAAgB;AAC7G;AALS;AAOT,SAAS,iBAAiB,gBAAgC;AACzD,SAAO,CAAC,OAAe,QACtB,eAAe,SAAS,IAAI,QAAwB,IACjD,OACA,IAAI,qCAAqC,gBAAgB,sBAAsB,OAAO,cAAc;AACzG;AALS;;;ACQT,SAAS,uBAAuB,YAAwB,MAA4B,UAAkB,QAAqC;AAC1I,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,aAAO,WAAW,MAAM,QAAQ,MAAM,IACnC,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,MAAM,yBAAyB,OAAO,QAAQ,CAAC;AAAA,IAC1F;AAAA,EACD;AACD;AARS;AAUF,SAAS,qBAAqB,QAAqC;AACzE,QAAM,WAAW,qBAAqB;AACtC,SAAO,uBAAuB,UAAU,2BAA2B,UAAU,MAAM;AACpF;AAHgB;AAKT,SAAS,4BAA4B,QAAqC;AAChF,QAAM,WAAW,sBAAsB;AACvC,SAAO,uBAAuB,iBAAiB,kCAAkC,UAAU,MAAM;AAClG;AAHgB;AAKT,SAAS,wBAAwB,QAAqC;AAC5E,QAAM,WAAW,qBAAqB;AACtC,SAAO,uBAAuB,aAAa,8BAA8B,UAAU,MAAM;AAC1F;AAHgB;AAKT,SAAS,+BAA+B,QAAqC;AACnF,QAAM,WAAW,sBAAsB;AACvC,SAAO,uBAAuB,oBAAoB,qCAAqC,UAAU,MAAM;AACxG;AAHgB;AAKT,SAAS,kBAAkB,QAAqC;AACtE,QAAM,WAAW,uBAAuB;AACxC,SAAO,uBAAuB,OAAO,wBAAwB,UAAU,MAAM;AAC9E;AAHgB;AAKT,SAAS,qBAAqB,QAAqC;AACzE,QAAM,WAAW,uBAAuB;AACxC,SAAO,uBAAuB,UAAU,2BAA2B,UAAU,MAAM;AACpF;AAHgB;AAKT,SAAS,cAAmC;AAClD,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,aAAO,cAAc,KAAK,IACvB,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,kBAAkB,yBAAyB,OAAO,iCAAiC,CAAC;AAAA,IAC/H;AAAA,EACD;AACD;AARgB;AAUhB,SAAS,qBAAqB,MAA4B,UAAkB,OAAoC;AAC/G,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,aAAO,MAAM,KAAK,KAAK,IACpB,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,MAAM,yBAAyB,OAAO,QAAQ,CAAC;AAAA,IAC1F;AAAA,EACD;AACD;AARS;AAUF,SAAS,UAAU,SAA2C;AACpE,QAAM,cAAc,oBAAoB,OAAO;AAC/C,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,UAAI;AACJ,UAAI;AACH,cAAM,IAAI,IAAI,KAAK;AAAA,MACpB,QAAE;AACD,eAAO,OAAO,IAAI,IAAI,wBAAwB,gBAAgB,eAAe,OAAO,yBAAyB,CAAC;AAAA,MAC/G;AAEA,YAAM,oBAAoB,YAAY,OAAO,GAAG;AAChD,UAAI,sBAAsB;AAAM,eAAO,OAAO,GAAG,KAAK;AACtD,aAAO,OAAO,IAAI,iBAAiB;AAAA,IACpC;AAAA,EACD;AACD;AAhBgB;AAkBT,SAAS,SAAS,SAAsC;AAC9D,QAAM,YAAY,UAAW,IAAI,YAAsB;AACvD,QAAM,cAAc,YAAY,IAAI,SAAS,YAAY,IAAI,SAAS;AAEtE,QAAM,OAAO,cAAc;AAC3B,QAAM,UAAU,aAAa;AAC7B,QAAM,WAAW,uBAAuB;AACxC,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,aAAO,YAAY,KAAK,IAAI,OAAO,GAAG,KAAK,IAAI,OAAO,IAAI,IAAI,wBAAwB,MAAM,SAAS,OAAO,QAAQ,CAAC;AAAA,IACtH;AAAA,EACD;AACD;AAZgB;AAcT,SAAS,YAAY,OAAe;AAC1C,SAAO,qBAAqB,kBAAkB,YAAY,mCAAmC,KAAK;AACnG;AAFgB;AAIT,SAAS,WAAW,EAAE,UAAU,GAAG,WAAW,MAAM,IAAuB,CAAC,GAAG;AACrF,wBAAY;AACZ,QAAM,QAAQ,IAAI;AAAA,IACjB,gCAAgC,qDAC/B,WAAW,0CAA0C;AAAA,IAEtD;AAAA,EACD;AACA,QAAM,WAAW,yBAAyB,OAAO,YAAY,WAAW,IAAI,YAAY,gBAAgB;AACxG,SAAO,qBAAqB,iBAAiB,UAAU,KAAK;AAC7D;AAVgB;AAYT,SAAS,aAAkC;AACjD,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,YAAM,OAAO,KAAK,MAAM,KAAK;AAE7B,aAAO,OAAO,MAAM,IAAI,IACrB,OAAO;AAAA,QACP,IAAI;AAAA,UACH;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACD;AAAA,MACA,IACA,OAAO,GAAG,KAAK;AAAA,IACnB;AAAA,EACD;AACD;AAjBgB;AAmBT,SAAS,cAAmC;AAClD,SAAO;AAAA,IACN,IAAI,OAAe;AAClB,aAAO,oBAAoB,KAAK,IAC7B,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,kBAAkB,wBAAwB,OAAO,+BAA+B,CAAC;AAAA,IAC5H;AAAA,EACD;AACD;AARgB;;;AC7IT,IAAM,kBAAN,cAAgD,cAAiB;AAAA,EAChE,eAAe,QAAsB;AAC3C,WAAO,KAAK,cAAc,qBAAqB,MAAM,CAAmB;AAAA,EACzE;AAAA,EAEO,sBAAsB,QAAsB;AAClD,WAAO,KAAK,cAAc,4BAA4B,MAAM,CAAmB;AAAA,EAChF;AAAA,EAEO,kBAAkB,QAAsB;AAC9C,WAAO,KAAK,cAAc,wBAAwB,MAAM,CAAmB;AAAA,EAC5E;AAAA,EAEO,yBAAyB,QAAsB;AACrD,WAAO,KAAK,cAAc,+BAA+B,MAAM,CAAmB;AAAA,EACnF;AAAA,EAEO,YAAY,QAAsB;AACxC,WAAO,KAAK,cAAc,kBAAkB,MAAM,CAAmB;AAAA,EACtE;AAAA,EAEO,eAAe,QAAsB;AAC3C,WAAO,KAAK,cAAc,qBAAqB,MAAM,CAAmB;AAAA,EACzE;AAAA,EAEA,IAAW,QAAc;AACxB,WAAO,KAAK,cAAc,YAAY,CAAmB;AAAA,EAC1D;AAAA,EAEO,IAAI,SAA4B;AACtC,WAAO,KAAK,cAAc,UAAU,OAAO,CAAmB;AAAA,EAC/D;AAAA,EAEO,KAAK,SAAmC;AAC9C,WAAO,KAAK,cAAc,WAAW,OAAO,CAAmB;AAAA,EAChE;AAAA,EAEO,MAAM,OAAqB;AACjC,WAAO,KAAK,cAAc,YAAY,KAAK,CAAmB;AAAA,EAC/D;AAAA,EAEA,IAAW,OAAO;AACjB,WAAO,KAAK,cAAc,WAAW,CAAmB;AAAA,EACzD;AAAA,EAEA,IAAW,OAAa;AACvB,WAAO,KAAK,GAAG,CAAC;AAAA,EACjB;AAAA,EAEA,IAAW,OAAa;AACvB,WAAO,KAAK,GAAG,CAAC;AAAA,EACjB;AAAA,EAEO,GAAG,SAAuB;AAChC,WAAO,KAAK,cAAc,SAAS,OAAO,CAAmB;AAAA,EAC9D;AAAA,EAEO,QAAc;AACpB,WAAO,KAAK,cAAc,YAAY,CAAmB;AAAA,EAC1D;AAAA,EAEU,OAAO,OAA4C;AAC5D,WAAO,OAAO,UAAU,WACrB,OAAO,GAAG,KAAU,IACpB,OAAO,IAAI,IAAI,gBAAgB,YAAY,+BAA+B,KAAK,CAAC;AAAA,EACpF;AACD;AAlEa;;;ACfN,IAAM,iBAAN,cAA8C,cAAsB;AAAA,EAGnE,YAAY,YAAqC,cAA8C,CAAC,GAAG;AACzG,UAAM,WAAW;AAHlB,SAAiB,aAAsC,CAAC;AAIvD,SAAK,aAAa;AAAA,EACnB;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,YAAY,KAAK,WAAW,CAAC;AAAA,EAC/E;AAAA,EAEU,OAAO,QAA0E;AAC1F,QAAI,CAAC,MAAM,QAAQ,MAAM,GAAG;AAC3B,aAAO,OAAO,IAAI,IAAI,gBAAgB,cAAc,qBAAqB,MAAM,CAAC;AAAA,IACjF;AAEA,QAAI,OAAO,WAAW,KAAK,WAAW,QAAQ;AAC7C,aAAO,OAAO,IAAI,IAAI,gBAAgB,cAAc,+BAA+B,KAAK,WAAW,UAAU,MAAM,CAAC;AAAA,IACrH;AAEA,QAAI,CAAC,KAAK,sBAAsB;AAC/B,aAAO,OAAO,GAAG,MAAgB;AAAA,IAClC;AAEA,UAAM,SAAgC,CAAC;AACvC,UAAM,cAAiB,CAAC;AAExB,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACvC,YAAM,SAAS,KAAK,WAAW,CAAC,EAAE,IAAI,OAAO,CAAC,CAAC;AAC/C,UAAI,OAAO,KAAK;AAAG,oBAAY,KAAK,OAAO,KAAK;AAAA;AAC3C,eAAO,KAAK,CAAC,GAAG,OAAO,KAAM,CAAC;AAAA,IACpC;AAEA,WAAO,OAAO,WAAW,IACtB,OAAO,GAAG,WAAW,IACrB,OAAO,IAAI,IAAI,sBAAsB,MAAM,CAAC;AAAA,EAChD;AACD;AAtCa;;;ACAN,IAAM,eAAN,cAAiC,cAAyB;AAAA,EAIzD,YAAY,cAAgC,gBAAkC,cAAiD,CAAC,GAAG;AACzI,UAAM,WAAW;AACjB,SAAK,eAAe;AACpB,SAAK,iBAAiB;AAAA,EACvB;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,cAAc,KAAK,gBAAgB,KAAK,WAAW,CAAC;AAAA,EACtG;AAAA,EAEU,OAAO,OAA4E;AAC5F,QAAI,EAAE,iBAAiB,MAAM;AAC5B,aAAO,OAAO,IAAI,IAAI,gBAAgB,eAAe,kBAAkB,KAAK,CAAC;AAAA,IAC9E;AAEA,QAAI,CAAC,KAAK,sBAAsB;AAC/B,aAAO,OAAO,GAAG,KAAK;AAAA,IACvB;AAEA,UAAM,SAAgC,CAAC;AACvC,UAAM,cAAc,oBAAI,IAAU;AAElC,eAAW,CAAC,KAAK,GAAG,KAAK,MAAM,QAAQ,GAAG;AACzC,YAAM,YAAY,KAAK,aAAa,IAAI,GAAG;AAC3C,YAAM,cAAc,KAAK,eAAe,IAAI,GAAG;AAC/C,YAAM,EAAE,OAAO,IAAI;AACnB,UAAI,UAAU,MAAM;AAAG,eAAO,KAAK,CAAC,KAAK,UAAU,KAAK,CAAC;AACzD,UAAI,YAAY,MAAM;AAAG,eAAO,KAAK,CAAC,KAAK,YAAY,KAAK,CAAC;AAC7D,UAAI,OAAO,WAAW;AAAQ,oBAAY,IAAI,UAAU,OAAQ,YAAY,KAAM;AAAA,IACnF;AAEA,WAAO,OAAO,WAAW,IACtB,OAAO,GAAG,WAAW,IACrB,OAAO,IAAI,IAAI,sBAAsB,MAAM,CAAC;AAAA,EAChD;AACD;AAvCa;;;ACHN,IAAM,gBAAN,cAA6E,cAAiB;AAAA,EAG7F,YAAY,WAAkC,cAAyC,CAAC,GAAG;AACjG,UAAM,WAAW;AACjB,SAAK,YAAY;AAAA,EAClB;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,WAAW,KAAK,WAAW,CAAC;AAAA,EAC9E;AAAA,EAEU,OAAO,QAA4C;AAC5D,WAAO,KAAK,UAAU,MAAM,EAAE,IAAI,MAAM;AAAA,EACzC;AACD;AAfa;;;ACDN,IAAM,wBAAN,cAAoC,UAAU;AAAA,EAK7C,YAAY,OAAwB,MAAgB,cAAqD;AAC/G,UAAM,4DAA4D;AAElE,SAAK,QAAQ;AACb,SAAK,WAAW;AAChB,SAAK,eAAe;AAAA,EACrB;AAAA,EAEO,SAAS;AACf,WAAO;AAAA,MACN,MAAM,KAAK;AAAA,MACX,OAAO,KAAK;AAAA,MACZ,UAAU,KAAK;AAAA,MACf,cAAc,CAAC,GAAG,KAAK,aAAa,QAAQ,CAAC;AAAA,IAC9C;AAAA,EACD;AAAA,EAEA,CAAW,4BAA4B,EAAE,OAAe,SAAyC;AAChG,UAAM,QAAQ,QAAQ,QAAQ,KAAK,MAAM,SAAS,GAAG,QAAQ;AAC7D,QAAI,QAAQ,GAAG;AACd,aAAO,QAAQ,QAAQ,2BAA2B,UAAU,SAAS;AAAA,IACtE;AAEA,UAAM,UAAU;AAAA,IAAO,QAAQ,QAAQ,KAAK,WAAW;AACvD,UAAM,QAAQ,KAAK,SACjB,IAAI,CAAC,QAAQ;AACb,YAAM,YAAY,KAAK,aAAa,IAAI,GAAG;AAC3C,aAAO,GAAG,QAAQ,QAAQ,KAAK,QAAQ,QAAQ,QAAQ;AAAA,QACtD,UAAU,SAAS;AAAA,QACnB,OAAO,cAAc,WAAW,WAAW;AAAA,MAC5C;AAAA,IACD,CAAC,EACA,KAAK,OAAO;AAEd,UAAM,SAAS,GAAG,QAAQ,QAAQ,yBAAyB,SAAS,OAAO;AAC3E,UAAM,UAAU,QAAQ,QAAQ,KAAK,SAAS,QAAQ;AACtD,UAAM,aAAa,GAAG,UAAU;AAChC,WAAO,GAAG;AAAA,IAAa;AAAA,EAAY;AAAA,EACpC;AACD;AA5Ca;;;ACEN,IAAM,sBAAN,cAA4D,cAA0B;AAAA,EAMrF,YAAY,WAAc;AAChC,UAAM;AALP,SAAgB,qBAA8B;AAE9C,SAAiB,cAAc,oBAAI,IAAiC;AAInE,SAAK,YAAY;AAEjB,SAAK,WAAW,OAAO,KAAK,SAAS,EAAE,OAAO,CAAC,QAAQ;AACtD,aAAO,OAAO,UAAU,UAAU,GAAG,CAAC,MAAM;AAAA,IAC7C,CAAC;AAED,eAAW,OAAO,KAAK,UAAU;AAChC,YAAM,YAAY,UAAU,GAAG;AAE/B,WAAK,YAAY,IAAI,KAAK,SAAS;AACnC,WAAK,YAAY,IAAI,WAAW,SAAS;AAEzC,UAAI,OAAO,cAAc,UAAU;AAClC,aAAK,qBAAqB;AAC1B,aAAK,YAAY,IAAI,GAAG,aAAa,SAAS;AAAA,MAC/C;AAAA,IACD;AAAA,EACD;AAAA,EAEmB,OAAO,OAA6E;AACtG,UAAM,cAAc,OAAO;AAE3B,QAAI,gBAAgB,UAAU;AAC7B,UAAI,CAAC,KAAK,oBAAoB;AAC7B,eAAO,OAAO,IAAI,IAAI,gBAAgB,mBAAmB,qCAAqC,KAAK,CAAC;AAAA,MACrG;AAAA,IACD,WAAW,gBAAgB,UAAU;AAEpC,aAAO,OAAO,IAAI,IAAI,gBAAgB,mBAAmB,+CAA+C,KAAK,CAAC;AAAA,IAC/G;AAEA,UAAM,SAAS;AAEf,UAAM,oBAAoB,KAAK,YAAY,IAAI,MAAM;AAErD,WAAO,OAAO,sBAAsB,cACjC,OAAO,IAAI,IAAI,sBAAsB,QAAQ,KAAK,UAAU,KAAK,WAAW,CAAC,IAC7E,OAAO,GAAG,iBAAiB;AAAA,EAC/B;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,SAAS,CAAC;AAAA,EAC5D;AACD;AAnDa;;;ACYb,SAAS,+BACR,YACA,MACA,UACA,QACiB;AACjB,SAAO;AAAA,IACN,IAAI,OAAU;AACb,aAAO,WAAW,MAAM,YAAY,MAAM,IACvC,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,MAAM,mCAAmC,OAAO,QAAQ,CAAC;AAAA,IACpG;AAAA,EACD;AACD;AAbS;AAeF,SAAS,6BAAmD,OAA+B;AACjG,QAAM,WAAW,yBAAyB;AAC1C,SAAO,+BAA+B,UAAU,sCAAsC,UAAU,KAAK;AACtG;AAHgB;AAKT,SAAS,oCAA0D,OAA+B;AACxG,QAAM,WAAW,0BAA0B;AAC3C,SAAO,+BAA+B,iBAAiB,6CAA6C,UAAU,KAAK;AACpH;AAHgB;AAKT,SAAS,gCAAsD,OAA+B;AACpG,QAAM,WAAW,yBAAyB;AAC1C,SAAO,+BAA+B,aAAa,yCAAyC,UAAU,KAAK;AAC5G;AAHgB;AAKT,SAAS,uCAA6D,OAA+B;AAC3G,QAAM,WAAW,0BAA0B;AAC3C,SAAO,+BAA+B,oBAAoB,gDAAgD,UAAU,KAAK;AAC1H;AAHgB;AAKT,SAAS,0BAAgD,OAA+B;AAC9F,QAAM,WAAW,2BAA2B;AAC5C,SAAO,+BAA+B,OAAO,mCAAmC,UAAU,KAAK;AAChG;AAHgB;AAKT,SAAS,6BAAmD,OAA+B;AACjG,QAAM,WAAW,2BAA2B;AAC5C,SAAO,+BAA+B,UAAU,sCAAsC,UAAU,KAAK;AACtG;AAHgB;AAKT,SAAS,0BAAgD,OAAe,WAAmC;AACjH,QAAM,WAAW,0BAA0B,kCAAkC;AAC7E,SAAO;AAAA,IACN,IAAI,OAAU;AACb,aAAO,MAAM,cAAc,SAAS,MAAM,aAAa,YACpD,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,mCAAmC,mCAAmC,OAAO,QAAQ,CAAC;AAAA,IACjI;AAAA,EACD;AACD;AATgB;AAWT,SAAS,mCAAyD,OAAe,KAAa;AACpG,QAAM,WAAW,0BAA0B,mCAAmC;AAC9E,SAAO;AAAA,IACN,IAAI,OAAU;AACb,aAAO,MAAM,cAAc,SAAS,MAAM,cAAc,MACrD,OAAO,GAAG,KAAK,IACf,OAAO;AAAA,QACP,IAAI,wBAAwB,4CAA4C,mCAAmC,OAAO,QAAQ;AAAA,MAC1H;AAAA,IACJ;AAAA,EACD;AACD;AAXgB;AAaT,SAAS,mCAAyD,YAAoB,WAAmC;AAC/H,QAAM,WAAW,yBAAyB,uCAAuC;AACjF,SAAO;AAAA,IACN,IAAI,OAAU;AACb,aAAO,MAAM,aAAa,cAAc,MAAM,aAAa,YACxD,OAAO,GAAG,KAAK,IACf,OAAO;AAAA,QACP,IAAI,wBAAwB,4CAA4C,mCAAmC,OAAO,QAAQ;AAAA,MAC1H;AAAA,IACJ;AAAA,EACD;AACD;AAXgB;AAahB,SAAS,2BACR,YACA,MACA,UACA,QACiB;AACjB,SAAO;AAAA,IACN,IAAI,OAAU;AACb,aAAO,WAAW,MAAM,QAAQ,MAAM,IACnC,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,MAAM,8BAA8B,OAAO,QAAQ,CAAC;AAAA,IAC/F;AAAA,EACD;AACD;AAbS;AAeF,SAAS,yBAA+C,OAA+B;AAC7F,QAAM,WAAW,qBAAqB;AACtC,SAAO,2BAA2B,UAAU,kCAAkC,UAAU,KAAK;AAC9F;AAHgB;AAKT,SAAS,gCAAsD,OAA+B;AACpG,QAAM,WAAW,sBAAsB;AACvC,SAAO,2BAA2B,iBAAiB,yCAAyC,UAAU,KAAK;AAC5G;AAHgB;AAKT,SAAS,4BAAkD,OAA+B;AAChG,QAAM,WAAW,qBAAqB;AACtC,SAAO,2BAA2B,aAAa,qCAAqC,UAAU,KAAK;AACpG;AAHgB;AAKT,SAAS,mCAAyD,OAA+B;AACvG,QAAM,WAAW,sBAAsB;AACvC,SAAO,2BAA2B,oBAAoB,4CAA4C,UAAU,KAAK;AAClH;AAHgB;AAKT,SAAS,sBAA4C,OAA+B;AAC1F,QAAM,WAAW,uBAAuB;AACxC,SAAO,2BAA2B,OAAO,+BAA+B,UAAU,KAAK;AACxF;AAHgB;AAKT,SAAS,yBAA+C,OAA+B;AAC7F,QAAM,WAAW,uBAAuB;AACxC,SAAO,2BAA2B,UAAU,kCAAkC,UAAU,KAAK;AAC9F;AAHgB;AAKT,SAAS,sBAA4C,OAAe,WAAmC;AAC7G,QAAM,WAAW,sBAAsB,8BAA8B;AACrE,SAAO;AAAA,IACN,IAAI,OAAU;AACb,aAAO,MAAM,UAAU,SAAS,MAAM,SAAS,YAC5C,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,+BAA+B,8BAA8B,OAAO,QAAQ,CAAC;AAAA,IACxH;AAAA,EACD;AACD;AATgB;AAWT,SAAS,+BAAqD,OAAe,KAA6B;AAChH,QAAM,WAAW,sBAAsB,+BAA+B;AACtE,SAAO;AAAA,IACN,IAAI,OAAU;AACb,aAAO,MAAM,UAAU,SAAS,MAAM,UAAU,MAC7C,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,wCAAwC,8BAA8B,OAAO,QAAQ,CAAC;AAAA,IACjI;AAAA,EACD;AACD;AATgB;AAWT,SAAS,+BAAqD,YAAoB,WAAmC;AAC3H,QAAM,WAAW,qBAAqB,mCAAmC;AACzE,SAAO;AAAA,IACN,IAAI,OAAU;AACb,aAAO,MAAM,SAAS,cAAc,MAAM,SAAS,YAChD,OAAO,GAAG,KAAK,IACf,OAAO,IAAI,IAAI,wBAAwB,wCAAwC,8BAA8B,OAAO,QAAQ,CAAC;AAAA,IACjI;AAAA,EACD;AACD;AATgB;;;ACtKhB,IAAM,SAAS,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG;AAEhC,IAAM,QAAQ,wBAAC,SAAiB;AACtC,SAAO,GAAG,OAAO,SAAS,KAAK,CAAC,EAAE,YAAY,CAAC,IAAI,OAAO,OAAO;AAClE,GAFqB;;;ACWd,IAAM,cAAc;AAAA,EAC1B,WAAW,CAAC,MAA+B,aAAa;AAAA,EACxD,YAAY,CAAC,MAAgC,aAAa;AAAA,EAC1D,mBAAmB,CAAC,MAAuC,aAAa;AAAA,EACxE,YAAY,CAAC,MAAgC,aAAa;AAAA,EAC1D,aAAa,CAAC,MAAiC,aAAa;AAAA,EAC5D,YAAY,CAAC,MAAgC,aAAa;AAAA,EAC1D,aAAa,CAAC,MAAiC,aAAa;AAAA,EAC5D,cAAc,CAAC,MAAkC,aAAa;AAAA,EAC9D,cAAc,CAAC,MAAkC,aAAa;AAAA,EAC9D,eAAe,CAAC,MAAmC,aAAa;AAAA,EAChE,gBAAgB,CAAC,MAAoC,aAAa;AAAA,EAClE,YAAY,CAAC,MAAgC,YAAY,OAAO,CAAC,KAAK,EAAE,aAAa;AACtF;;;ACCO,IAAM,sBAAN,cAAwD,cAAiB;AAAA,EAGxE,YAAY,MAAsB,cAAyC,CAAC,GAAG;AACrF,UAAM,WAAW;AACjB,SAAK,OAAO;AAAA,EACb;AAAA,EAEO,mBAAmB,QAAgB;AACzC,WAAO,KAAK,cAAc,6BAA6B,MAAM,CAAC;AAAA,EAC/D;AAAA,EAEO,0BAA0B,QAAgB;AAChD,WAAO,KAAK,cAAc,oCAAoC,MAAM,CAAC;AAAA,EACtE;AAAA,EAEO,sBAAsB,QAAgB;AAC5C,WAAO,KAAK,cAAc,gCAAgC,MAAM,CAAC;AAAA,EAClE;AAAA,EAEO,6BAA6B,QAAgB;AACnD,WAAO,KAAK,cAAc,uCAAuC,MAAM,CAAC;AAAA,EACzE;AAAA,EAEO,gBAAgB,QAAgB;AACtC,WAAO,KAAK,cAAc,0BAA0B,MAAM,CAAC;AAAA,EAC5D;AAAA,EAEO,mBAAmB,QAAgB;AACzC,WAAO,KAAK,cAAc,6BAA6B,MAAM,CAAC;AAAA,EAC/D;AAAA,EAEO,gBAAgB,OAAe,WAAmB;AACxD,WAAO,KAAK,cAAc,0BAA0B,OAAO,SAAS,CAAC;AAAA,EACtE;AAAA,EAEO,yBAAyB,SAAiB,OAAe;AAC/D,WAAO,KAAK,cAAc,mCAAmC,SAAS,KAAK,CAAmB;AAAA,EAC/F;AAAA,EAEO,yBAAyB,YAAoB,WAAmB;AACtE,WAAO,KAAK,cAAc,mCAAmC,YAAY,SAAS,CAAC;AAAA,EACpF;AAAA,EAEO,eAAe,QAAgB;AACrC,WAAO,KAAK,cAAc,yBAAyB,MAAM,CAAC;AAAA,EAC3D;AAAA,EAEO,sBAAsB,QAAgB;AAC5C,WAAO,KAAK,cAAc,gCAAgC,MAAM,CAAC;AAAA,EAClE;AAAA,EAEO,kBAAkB,QAAgB;AACxC,WAAO,KAAK,cAAc,4BAA4B,MAAM,CAAC;AAAA,EAC9D;AAAA,EAEO,yBAAyB,QAAgB;AAC/C,WAAO,KAAK,cAAc,mCAAmC,MAAM,CAAC;AAAA,EACrE;AAAA,EAEO,YAAY,QAAgB;AAClC,WAAO,KAAK,cAAc,sBAAsB,MAAM,CAAC;AAAA,EACxD;AAAA,EAEO,eAAe,QAAgB;AACrC,WAAO,KAAK,cAAc,yBAAyB,MAAM,CAAC;AAAA,EAC3D;AAAA,EAEO,YAAY,OAAe,WAAmB;AACpD,WAAO,KAAK,cAAc,sBAAsB,OAAO,SAAS,CAAC;AAAA,EAClE;AAAA,EAEO,qBAAqB,SAAiB,OAAe;AAC3D,WAAO,KAAK,cAAc,+BAA+B,SAAS,KAAK,CAAC;AAAA,EACzE;AAAA,EAEO,qBAAqB,YAAoB,WAAmB;AAClE,WAAO,KAAK,cAAc,+BAA+B,YAAY,SAAS,CAAC;AAAA,EAChF;AAAA,EAEmB,QAAc;AAChC,WAAO,QAAQ,UAAU,KAAK,aAAa,CAAC,KAAK,MAAM,KAAK,WAAW,CAAC;AAAA,EACzE;AAAA,EAEU,OAAO,OAA4C;AAC5D,WAAO,YAAY,KAAK,IAAI,EAAE,KAAK,IAChC,OAAO,GAAG,KAAU,IACpB,OAAO,IAAI,IAAI,gBAAgB,gBAAgB,YAAY,MAAM,KAAK,IAAI,KAAK,KAAK,CAAC;AAAA,EACzF;AACD;AAzFa;;;ACAN,IAAM,SAAN,MAAa;AAAA,EACnB,IAAW,SAAS;AACnB,WAAO,IAAI,gBAAgB;AAAA,EAC5B;AAAA,EAEA,IAAW,SAAS;AACnB,WAAO,IAAI,gBAAgB;AAAA,EAC5B;AAAA,EAEA,IAAW,SAAS;AACnB,WAAO,IAAI,gBAAgB;AAAA,EAC5B;AAAA,EAEA,IAAW,UAAU;AACpB,WAAO,IAAI,iBAAiB;AAAA,EAC7B;AAAA,EAEA,IAAW,OAAO;AACjB,WAAO,IAAI,cAAc;AAAA,EAC1B;AAAA,EAEO,OAAyB,OAAiC;AAChE,WAAO,IAAI,gBAAmB,KAAK;AAAA,EACpC;AAAA,EAEA,IAAW,YAAY;AACtB,WAAO,KAAK,QAAQ,MAAS;AAAA,EAC9B;AAAA,EAEA,IAAW,OAAO;AACjB,WAAO,KAAK,QAAQ,IAAI;AAAA,EACzB;AAAA,EAEA,IAAW,UAAU;AACpB,WAAO,IAAI,iBAAiB;AAAA,EAC7B;AAAA,EAEA,IAAW,MAAM;AAChB,WAAO,IAAI,qBAA0B;AAAA,EACtC;AAAA,EAEA,IAAW,UAAU;AACpB,WAAO,IAAI,qBAA8B;AAAA,EAC1C;AAAA,EAEA,IAAW,QAAQ;AAClB,WAAO,IAAI,eAAe;AAAA,EAC3B;AAAA,EAEO,QAAW,QAAsB;AACvC,WAAO,KAAK,MAAM,GAAG,OAAO,IAAI,CAAC,UAAU,KAAK,QAAQ,KAAK,CAAC,CAAC;AAAA,EAChE;AAAA,EAEO,WAAqC,WAAsC;AACjF,WAAO,IAAI,oBAAoB,SAAS;AAAA,EACzC;AAAA,EAEO,QAAW,OAA4B;AAC7C,QAAI,iBAAiB;AAAM,aAAO,KAAK,KAAK,MAAM,KAAK;AACvD,WAAO,IAAI,iBAAiB,KAAK;AAAA,EAClC;AAAA,EAEO,SAAY,UAAgD;AAClE,WAAO,IAAI,kBAAkB,QAAQ;AAAA,EACtC;AAAA,EAEO,SAA8C,YAAuD;AAC3G,WAAO,IAAI,eAAe,UAAU;AAAA,EACrC;AAAA,EAIO,MAA2B,WAAqC;AACtE,WAAO,IAAI,eAAe,SAAS;AAAA,EACpC;AAAA,EAEO,WAAiC,OAAuB,cAAc;AAC5E,WAAO,IAAI,oBAAuB,IAAI;AAAA,EACvC;AAAA,EAEA,IAAW,YAAY;AACtB,WAAO,KAAK,WAAsB,WAAW;AAAA,EAC9C;AAAA,EAEA,IAAW,aAAa;AACvB,WAAO,KAAK,WAAuB,YAAY;AAAA,EAChD;AAAA,EAEA,IAAW,oBAAoB;AAC9B,WAAO,KAAK,WAA8B,mBAAmB;AAAA,EAC9D;AAAA,EAEA,IAAW,aAAa;AACvB,WAAO,KAAK,WAAuB,YAAY;AAAA,EAChD;AAAA,EAEA,IAAW,cAAc;AACxB,WAAO,KAAK,WAAwB,aAAa;AAAA,EAClD;AAAA,EAEA,IAAW,aAAa;AACvB,WAAO,KAAK,WAAuB,YAAY;AAAA,EAChD;AAAA,EAEA,IAAW,cAAc;AACxB,WAAO,KAAK,WAAwB,aAAa;AAAA,EAClD;AAAA,EAEA,IAAW,eAAe;AACzB,WAAO,KAAK,WAAyB,cAAc;AAAA,EACpD;AAAA,EAEA,IAAW,eAAe;AACzB,WAAO,KAAK,WAAyB,cAAc;AAAA,EACpD;AAAA,EAEA,IAAW,gBAAgB;AAC1B,WAAO,KAAK,WAA0B,eAAe;AAAA,EACtD;AAAA,EAEA,IAAW,iBAAiB;AAC3B,WAAO,KAAK,WAA2B,gBAAgB;AAAA,EACxD;AAAA,EAEO,MAA2C,YAAoD;AACrG,WAAO,IAAI,eAAe,UAAU;AAAA,EACrC;AAAA,EAEO,IAAO,WAA6B;AAC1C,WAAO,IAAI,aAAa,SAAS;AAAA,EAClC;AAAA,EAEO,OAAU,WAA6B;AAC7C,WAAO,IAAI,gBAAgB,SAAS;AAAA,EACrC;AAAA,EAEO,IAAU,cAAgC,gBAAkC;AAClF,WAAO,IAAI,aAAa,cAAc,cAAc;AAAA,EACrD;AAAA,EAEO,KAAuC,WAAkC;AAC/E,WAAO,IAAI,cAAc,SAAS;AAAA,EACnC;AACD;AA/Ia;;;ACzBN,IAAM,IAAI,IAAI,OAAO","sourcesContent":["let validationEnabled = true;\n\n/**\n * Sets whether validators should run on the input, or if the input should be passed through.\n * @param enabled Whether validation should be done on inputs\n */\nexport function setGlobalValidationEnabled(enabled: boolean) {\n\tvalidationEnabled = enabled;\n}\n\n/**\n * @returns Whether validation is enabled\n */\nexport function getGlobalValidationEnabled() {\n\treturn validationEnabled;\n}\n","export class Result<T, E extends Error = Error> {\n\tpublic readonly success: boolean;\n\tpublic readonly value?: T;\n\tpublic readonly error?: E;\n\n\tprivate constructor(success: boolean, value?: T, error?: E) {\n\t\tthis.success = success;\n\t\tif (success) {\n\t\t\tthis.value = value;\n\t\t} else {\n\t\t\tthis.error = error;\n\t\t}\n\t}\n\n\tpublic isOk(): this is { success: true; value: T } {\n\t\treturn this.success;\n\t}\n\n\tpublic isErr(): this is { success: false; error: E } {\n\t\treturn !this.success;\n\t}\n\n\tpublic unwrap(): T {\n\t\tif (this.isOk()) return this.value;\n\t\tthrow this.error as Error;\n\t}\n\n\tpublic static ok<T, E extends Error = Error>(value: T): Result<T, E> {\n\t\treturn new Result<T, E>(true, value);\n\t}\n\n\tpublic static err<T, E extends Error = Error>(error: E): Result<T, E> {\n\t\treturn new Result<T, E>(false, undefined, error);\n\t}\n}\n","// https://github.com/microsoft/TypeScript/issues/37663\ntype Fn = (...args: unknown[]) => unknown;\n\nexport function getValue<T, U = T extends Fn ? ReturnType<T> : T>(valueOrFn: T): U {\n\treturn typeof valueOrFn === 'function' ? valueOrFn() : valueOrFn;\n}\n","import get from 'lodash/get.js';\nimport { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { BaseValidator } from '../type-exports';\nimport type { IConstraint } from './type-exports';\n\nexport type ObjectConstraintName = `s.object(T.when)`;\n\nexport type WhenKey = PropertyKey | PropertyKey[];\n\nexport interface WhenOptions<T extends BaseValidator<any>, Key extends WhenKey> {\n\tis?: boolean | ((value: Key extends Array<any> ? any[] : any) => boolean);\n\tthen: (predicate: T) => T;\n\totherwise?: (predicate: T) => T;\n}\n\nexport function whenConstraint<T extends BaseValidator<any>, I, Key extends WhenKey>(\n\tkey: Key,\n\toptions: WhenOptions<T, Key>,\n\tvalidator: T\n): IConstraint<I> {\n\treturn {\n\t\trun(input: I, parent?: any) {\n\t\t\tif (!parent) {\n\t\t\t\treturn Result.err(new ExpectedConstraintError('s.object(T.when)', 'Validator has no parent', parent, 'Validator to have a parent'));\n\t\t\t}\n\n\t\t\tconst isKeyArray = Array.isArray(key);\n\n\t\t\tconst value = isKeyArray ? key.map((k) => get(parent, k)) : get(parent, key);\n\n\t\t\tconst predicate = resolveBooleanIs<T, Key>(options, value, isKeyArray) ? options.then : options.otherwise;\n\n\t\t\tif (predicate) {\n\t\t\t\treturn predicate(validator).run(input) as Result<I, ExpectedConstraintError<I>>;\n\t\t\t}\n\n\t\t\treturn Result.ok(input);\n\t\t}\n\t};\n}\n\nfunction resolveBooleanIs<T extends BaseValidator<any>, Key extends WhenKey>(options: WhenOptions<T, Key>, value: any, isKeyArray: boolean) {\n\tif (options.is === undefined) {\n\t\treturn isKeyArray ? !value.some((val: any) => !val) : Boolean(value);\n\t}\n\n\tif (typeof options.is === 'function') {\n\t\treturn options.is(value);\n\t}\n\n\treturn value === options.is;\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { customInspectSymbolStackLess } from './BaseError';\nimport { BaseConstraintError, type ConstraintErrorNames } from './BaseConstraintError';\n\nexport class ExpectedConstraintError<T = unknown> extends BaseConstraintError<T> {\n\tpublic readonly expected: string;\n\n\tpublic constructor(constraint: ConstraintErrorNames, message: string, given: T, expected: string) {\n\t\tsuper(constraint, message, given);\n\t\tthis.expected = expected;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tconstraint: this.constraint,\n\t\t\tgiven: this.given,\n\t\t\texpected: this.expected\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst constraint = options.stylize(this.constraint, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[ExpectedConstraintError: ${constraint}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1 };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('ExpectedConstraintError', 'special')} > ${constraint}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst expectedBlock = `\\n ${options.stylize('Expected: ', 'string')}${options.stylize(this.expected, 'boolean')}`;\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${expectedBlock}\\n${givenBlock}`;\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\n\nexport const customInspectSymbol = Symbol.for('nodejs.util.inspect.custom');\nexport const customInspectSymbolStackLess = Symbol.for('nodejs.util.inspect.custom.stack-less');\n\nexport abstract class BaseError extends Error {\n\tprotected [customInspectSymbol](depth: number, options: InspectOptionsStylized) {\n\t\treturn `${this[customInspectSymbolStackLess](depth, options)}\\n${this.stack!.slice(this.stack!.indexOf('\\n'))}`;\n\t}\n\n\tprotected abstract [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string;\n}\n","import type {\n\tArrayConstraintName,\n\tBigIntConstraintName,\n\tBooleanConstraintName,\n\tDateConstraintName,\n\tNumberConstraintName,\n\tObjectConstraintName,\n\tStringConstraintName,\n\tTypedArrayConstraintName\n} from '../../constraints/type-exports';\nimport { BaseError } from './BaseError';\n\nexport type ConstraintErrorNames =\n\t| TypedArrayConstraintName\n\t| ArrayConstraintName\n\t| BigIntConstraintName\n\t| BooleanConstraintName\n\t| DateConstraintName\n\t| NumberConstraintName\n\t| ObjectConstraintName\n\t| StringConstraintName;\n\nexport abstract class BaseConstraintError<T = unknown> extends BaseError {\n\tpublic readonly constraint: ConstraintErrorNames;\n\tpublic readonly given: T;\n\n\tpublic constructor(constraint: ConstraintErrorNames, message: string, given: T) {\n\t\tsuper(message);\n\t\tthis.constraint = constraint;\n\t\tthis.given = given;\n\t}\n}\n","import { getGlobalValidationEnabled } from '../lib/configs';\nimport { Result } from '../lib/Result';\nimport { ArrayValidator, DefaultValidator, LiteralValidator, NullishValidator, SetValidator, UnionValidator } from './imports';\nimport { getValue } from './util/getValue';\nimport { whenConstraint, type WhenKey, type WhenOptions } from '../constraints/ObjectConstrains';\nimport type { CombinedError } from '../lib/errors/CombinedError';\nimport type { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport type { UnknownEnumValueError } from '../lib/errors/UnknownEnumValueError';\nimport type { ValidationError } from '../lib/errors/ValidationError';\nimport type { BaseConstraintError, InferResultType } from '../type-exports';\nimport type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\n\nexport abstract class BaseValidator<T> {\n\tpublic description?: string;\n\tprotected parent?: object;\n\tprotected constraints: readonly IConstraint<T>[] = [];\n\tprotected isValidationEnabled: boolean | (() => boolean) | null = null;\n\n\tpublic constructor(constraints: readonly IConstraint<T>[] = []) {\n\t\tthis.constraints = constraints;\n\t}\n\n\tpublic setParent(parent: object): this {\n\t\tthis.parent = parent;\n\t\treturn this;\n\t}\n\n\tpublic get optional(): UnionValidator<T | undefined> {\n\t\treturn new UnionValidator([new LiteralValidator(undefined), this.clone()]);\n\t}\n\n\tpublic get nullable(): UnionValidator<T | null> {\n\t\treturn new UnionValidator([new LiteralValidator(null), this.clone()]);\n\t}\n\n\tpublic get nullish(): UnionValidator<T | null | undefined> {\n\t\treturn new UnionValidator([new NullishValidator(), this.clone()]);\n\t}\n\n\tpublic get array(): ArrayValidator<T[]> {\n\t\treturn new ArrayValidator<T[]>(this.clone());\n\t}\n\n\tpublic get set(): SetValidator<T> {\n\t\treturn new SetValidator<T>(this.clone());\n\t}\n\n\tpublic or<O>(...predicates: readonly BaseValidator<O>[]): UnionValidator<T | O> {\n\t\treturn new UnionValidator<T | O>([this.clone(), ...predicates]);\n\t}\n\n\tpublic transform(cb: (value: T) => T): this;\n\tpublic transform<O>(cb: (value: T) => O): BaseValidator<O>;\n\tpublic transform<O>(cb: (value: T) => O): BaseValidator<O> {\n\t\treturn this.addConstraint({ run: (input) => Result.ok(cb(input) as unknown as T) }) as unknown as BaseValidator<O>;\n\t}\n\n\tpublic reshape(cb: (input: T) => Result<T>): this;\n\tpublic reshape<R extends Result<unknown>, O = InferResultType<R>>(cb: (input: T) => R): BaseValidator<O>;\n\tpublic reshape<R extends Result<unknown>, O = InferResultType<R>>(cb: (input: T) => R): BaseValidator<O> {\n\t\treturn this.addConstraint({ run: cb as unknown as (input: T) => Result<T, BaseConstraintError<T>> }) as unknown as BaseValidator<O>;\n\t}\n\n\tpublic default(value: Exclude<T, undefined> | (() => Exclude<T, undefined>)): DefaultValidator<Exclude<T, undefined>> {\n\t\treturn new DefaultValidator(this.clone() as unknown as BaseValidator<Exclude<T, undefined>>, value);\n\t}\n\n\tpublic when<Key extends WhenKey, This extends BaseValidator<any> = this>(key: Key, options: WhenOptions<This, Key>): this {\n\t\treturn this.addConstraint(whenConstraint<This, T, Key>(key, options, this as unknown as This));\n\t}\n\n\tpublic describe(description: string): this {\n\t\tconst clone = this.clone();\n\t\tclone.description = description;\n\t\treturn clone;\n\t}\n\n\tpublic run(value: unknown): Result<T, BaseError> {\n\t\tlet result = this.handle(value) as Result<T, BaseError>;\n\t\tif (result.isErr()) return result;\n\n\t\tfor (const constraint of this.constraints) {\n\t\t\tresult = constraint.run(result.value as T, this.parent);\n\t\t\tif (result.isErr()) break;\n\t\t}\n\n\t\treturn result;\n\t}\n\n\tpublic parse<R extends T = T>(value: unknown): R {\n\t\t// If validation is disabled (at the validator or global level), we only run the `handle` method, which will do some basic checks\n\t\t// (like that the input is a string for a string validator)\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn this.handle(value).unwrap() as R;\n\t\t}\n\n\t\treturn this.constraints.reduce((v, constraint) => constraint.run(v).unwrap(), this.handle(value).unwrap()) as R;\n\t}\n\n\tpublic is<R extends T = T>(value: unknown): value is R {\n\t\treturn this.run(value).isOk();\n\t}\n\n\t/**\n\t * Sets if the validator should also run constraints or just do basic checks.\n\t * @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.\n\t * Set to `null` to go off of the global configuration.\n\t */\n\tpublic setValidationEnabled(isValidationEnabled: boolean | (() => boolean) | null): this {\n\t\tconst clone = this.clone();\n\t\tclone.isValidationEnabled = isValidationEnabled;\n\t\treturn clone;\n\t}\n\n\tpublic getValidationEnabled() {\n\t\treturn getValue(this.isValidationEnabled);\n\t}\n\n\tprotected get shouldRunConstraints(): boolean {\n\t\treturn getValue(this.isValidationEnabled) ?? getGlobalValidationEnabled();\n\t}\n\n\tprotected clone(): this {\n\t\tconst clone: this = Reflect.construct(this.constructor, [this.constraints]);\n\t\tclone.isValidationEnabled = this.isValidationEnabled;\n\t\treturn clone;\n\t}\n\n\tprotected abstract handle(value: unknown): Result<T, ValidatorError>;\n\n\tprotected addConstraint(constraint: IConstraint<T>): this {\n\t\tconst clone = this.clone();\n\t\tclone.constraints = clone.constraints.concat(constraint);\n\t\treturn clone;\n\t}\n}\n\nexport type ValidatorError = ValidationError | CombinedError | CombinedPropertyError | UnknownEnumValueError;\n","import fastDeepEqual from 'fast-deep-equal/es6/index.js';\nimport uniqWith from 'lodash/uniqWith.js';\n\nexport function isUnique(input: unknown[]) {\n\tif (input.length < 2) return true;\n\tconst uniqueArray = uniqWith(input, fastDeepEqual);\n\treturn uniqueArray.length === input.length;\n}\n","export function lessThan(a: number, b: number): boolean;\nexport function lessThan(a: bigint, b: bigint): boolean;\nexport function lessThan(a: number | bigint, b: number | bigint): boolean {\n\treturn a < b;\n}\n\nexport function lessThanOrEqual(a: number, b: number): boolean;\nexport function lessThanOrEqual(a: bigint, b: bigint): boolean;\nexport function lessThanOrEqual(a: number | bigint, b: number | bigint): boolean {\n\treturn a <= b;\n}\n\nexport function greaterThan(a: number, b: number): boolean;\nexport function greaterThan(a: bigint, b: bigint): boolean;\nexport function greaterThan(a: number | bigint, b: number | bigint): boolean {\n\treturn a > b;\n}\n\nexport function greaterThanOrEqual(a: number, b: number): boolean;\nexport function greaterThanOrEqual(a: bigint, b: bigint): boolean;\nexport function greaterThanOrEqual(a: number | bigint, b: number | bigint): boolean {\n\treturn a >= b;\n}\n\nexport function equal(a: number, b: number): boolean;\nexport function equal(a: bigint, b: bigint): boolean;\nexport function equal(a: number | bigint, b: number | bigint): boolean {\n\treturn a === b;\n}\n\nexport function notEqual(a: number, b: number): boolean;\nexport function notEqual(a: bigint, b: bigint): boolean;\nexport function notEqual(a: number | bigint, b: number | bigint): boolean {\n\treturn a !== b;\n}\n\nexport interface Comparator {\n\t(a: number, b: number): boolean;\n\t(a: bigint, b: bigint): boolean;\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { isUnique } from './util/isUnique';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type ArrayConstraintName = `s.array(T).${\n\t| 'unique'\n\t| `length${\n\t\t\t| 'LessThan'\n\t\t\t| 'LessThanOrEqual'\n\t\t\t| 'GreaterThan'\n\t\t\t| 'GreaterThanOrEqual'\n\t\t\t| 'Equal'\n\t\t\t| 'NotEqual'\n\t\t\t| 'Range'\n\t\t\t| 'RangeInclusive'\n\t\t\t| 'RangeExclusive'}`}`;\n\nfunction arrayLengthComparator<T>(comparator: Comparator, name: ArrayConstraintName, expected: string, length: number): IConstraint<T[]> {\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn comparator(input.length, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function arrayLengthLessThan<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length < ${value}`;\n\treturn arrayLengthComparator(lessThan, 's.array(T).lengthLessThan', expected, value);\n}\n\nexport function arrayLengthLessThanOrEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length <= ${value}`;\n\treturn arrayLengthComparator(lessThanOrEqual, 's.array(T).lengthLessThanOrEqual', expected, value);\n}\n\nexport function arrayLengthGreaterThan<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length > ${value}`;\n\treturn arrayLengthComparator(greaterThan, 's.array(T).lengthGreaterThan', expected, value);\n}\n\nexport function arrayLengthGreaterThanOrEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length >= ${value}`;\n\treturn arrayLengthComparator(greaterThanOrEqual, 's.array(T).lengthGreaterThanOrEqual', expected, value);\n}\n\nexport function arrayLengthEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length === ${value}`;\n\treturn arrayLengthComparator(equal, 's.array(T).lengthEqual', expected, value);\n}\n\nexport function arrayLengthNotEqual<T>(value: number): IConstraint<T[]> {\n\tconst expected = `expected.length !== ${value}`;\n\treturn arrayLengthComparator(notEqual, 's.array(T).lengthNotEqual', expected, value);\n}\n\nexport function arrayLengthRange<T>(start: number, endBefore: number): IConstraint<T[]> {\n\tconst expected = `expected.length >= ${start} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn input.length >= start && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).lengthRange', 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function arrayLengthRangeInclusive<T>(start: number, end: number): IConstraint<T[]> {\n\tconst expected = `expected.length >= ${start} && expected.length <= ${end}`;\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn input.length >= start && input.length <= end //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).lengthRangeInclusive', 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function arrayLengthRangeExclusive<T>(startAfter: number, endBefore: number): IConstraint<T[]> {\n\tconst expected = `expected.length > ${startAfter} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T[]) {\n\t\t\treturn input.length > startAfter && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).lengthRangeExclusive', 'Invalid Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport const uniqueArray: IConstraint<unknown[]> = {\n\trun(input: unknown[]) {\n\t\treturn isUnique(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.array(T).unique', 'Array values are not unique', input, 'Expected all values to be unique'));\n\t}\n};\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class CombinedPropertyError extends BaseError {\n\tpublic readonly errors: [PropertyKey, BaseError][];\n\n\tpublic constructor(errors: [PropertyKey, BaseError][]) {\n\t\tsuper('Received one or more errors');\n\n\t\tthis.errors = errors;\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize('[CombinedPropertyError]', 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\n\t\tconst header = `${options.stylize('CombinedPropertyError', 'special')} (${options.stylize(this.errors.length.toString(), 'number')})`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst errors = this.errors\n\t\t\t.map(([key, error]) => {\n\t\t\t\tconst property = CombinedPropertyError.formatProperty(key, options);\n\t\t\t\tconst body = error[customInspectSymbolStackLess](depth - 1, newOptions).replace(/\\n/g, padding);\n\n\t\t\t\treturn ` input${property}${padding}${body}`;\n\t\t\t})\n\t\t\t.join('\\n\\n');\n\t\treturn `${header}\\n ${message}\\n\\n${errors}`;\n\t}\n\n\tprivate static formatProperty(key: PropertyKey, options: InspectOptionsStylized): string {\n\t\tif (typeof key === 'string') return options.stylize(`.${key}`, 'symbol');\n\t\tif (typeof key === 'number') return `[${options.stylize(key.toString(), 'number')}]`;\n\t\treturn `[${options.stylize('Symbol', 'symbol')}(${key.description})]`;\n\t}\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class ValidationError extends BaseError {\n\tpublic readonly validator: string;\n\tpublic readonly given: unknown;\n\n\tpublic constructor(validator: string, message: string, given: unknown) {\n\t\tsuper(message);\n\n\t\tthis.validator = validator;\n\t\tthis.given = given;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tvalidator: this.validator,\n\t\t\tgiven: this.given\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst validator = options.stylize(this.validator, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[ValidationError: ${validator}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('ValidationError', 'special')} > ${validator}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${givenBlock}`;\n\t}\n}\n","import {\n\tarrayLengthEqual,\n\tarrayLengthGreaterThan,\n\tarrayLengthGreaterThanOrEqual,\n\tarrayLengthLessThan,\n\tarrayLengthLessThanOrEqual,\n\tarrayLengthNotEqual,\n\tarrayLengthRange,\n\tarrayLengthRangeExclusive,\n\tarrayLengthRangeInclusive,\n\tuniqueArray\n} from '../constraints/ArrayConstraints';\nimport type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport type { ExpandSmallerTuples, Tuple, UnshiftTuple } from '../lib/util-types';\nimport { BaseValidator } from './imports';\n\nexport class ArrayValidator<T extends unknown[], I = T[number]> extends BaseValidator<T> {\n\tprivate readonly validator: BaseValidator<I>;\n\n\tpublic constructor(validator: BaseValidator<I>, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tpublic lengthLessThan<N extends number>(length: N): ArrayValidator<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, N>]>>> {\n\t\treturn this.addConstraint(arrayLengthLessThan(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthLessThanOrEqual<N extends number>(length: N): ArrayValidator<ExpandSmallerTuples<[...Tuple<I, N>]>> {\n\t\treturn this.addConstraint(arrayLengthLessThanOrEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthGreaterThan<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>, I, ...T]> {\n\t\treturn this.addConstraint(arrayLengthGreaterThan(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthGreaterThanOrEqual<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>, ...T]> {\n\t\treturn this.addConstraint(arrayLengthGreaterThanOrEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthEqual<N extends number>(length: N): ArrayValidator<[...Tuple<I, N>]> {\n\t\treturn this.addConstraint(arrayLengthEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthNotEqual(length: number): ArrayValidator<[...T]> {\n\t\treturn this.addConstraint(arrayLengthNotEqual(length) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthRange<S extends number, E extends number>(\n\t\tstart: S,\n\t\tendBefore: E\n\t): ArrayValidator<Exclude<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, E>]>>, ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, S>]>>>> {\n\t\treturn this.addConstraint(arrayLengthRange(start, endBefore) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthRangeInclusive<S extends number, E extends number>(\n\t\tstartAt: S,\n\t\tendAt: E\n\t): ArrayValidator<Exclude<ExpandSmallerTuples<[...Tuple<I, E>]>, ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, S>]>>>> {\n\t\treturn this.addConstraint(arrayLengthRangeInclusive(startAt, endAt) as IConstraint<T>) as any;\n\t}\n\n\tpublic lengthRangeExclusive<S extends number, E extends number>(\n\t\tstartAfter: S,\n\t\tendBefore: E\n\t): ArrayValidator<Exclude<ExpandSmallerTuples<UnshiftTuple<[...Tuple<I, E>]>>, ExpandSmallerTuples<[...Tuple<T, S>]>>> {\n\t\treturn this.addConstraint(arrayLengthRangeExclusive(startAfter, endBefore) as IConstraint<T>) as any;\n\t}\n\n\tpublic get unique(): this {\n\t\treturn this.addConstraint(uniqueArray as IConstraint<T>);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<T, ValidationError | CombinedPropertyError> {\n\t\tif (!Array.isArray(values)) {\n\t\t\treturn Result.err(new ValidationError('s.array(T)', 'Expected an array', values));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(values as T);\n\t\t}\n\n\t\tconst errors: [number, BaseError][] = [];\n\t\tconst transformed: T = [] as unknown as T;\n\n\t\tfor (let i = 0; i < values.length; i++) {\n\t\t\tconst result = this.validator.run(values[i]);\n\t\t\tif (result.isOk()) transformed.push(result.value);\n\t\t\telse errors.push([i, result.error!]);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type BigIntConstraintName = `s.bigint.${\n\t| 'lessThan'\n\t| 'lessThanOrEqual'\n\t| 'greaterThan'\n\t| 'greaterThanOrEqual'\n\t| 'equal'\n\t| 'notEqual'\n\t| 'divisibleBy'}`;\n\nfunction bigintComparator(comparator: Comparator, name: BigIntConstraintName, expected: string, number: bigint): IConstraint<bigint> {\n\treturn {\n\t\trun(input: bigint) {\n\t\t\treturn comparator(input, number) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid bigint value', input, expected));\n\t\t}\n\t};\n}\n\nexport function bigintLessThan(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected < ${value}n`;\n\treturn bigintComparator(lessThan, 's.bigint.lessThan', expected, value);\n}\n\nexport function bigintLessThanOrEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected <= ${value}n`;\n\treturn bigintComparator(lessThanOrEqual, 's.bigint.lessThanOrEqual', expected, value);\n}\n\nexport function bigintGreaterThan(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected > ${value}n`;\n\treturn bigintComparator(greaterThan, 's.bigint.greaterThan', expected, value);\n}\n\nexport function bigintGreaterThanOrEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected >= ${value}n`;\n\treturn bigintComparator(greaterThanOrEqual, 's.bigint.greaterThanOrEqual', expected, value);\n}\n\nexport function bigintEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected === ${value}n`;\n\treturn bigintComparator(equal, 's.bigint.equal', expected, value);\n}\n\nexport function bigintNotEqual(value: bigint): IConstraint<bigint> {\n\tconst expected = `expected !== ${value}n`;\n\treturn bigintComparator(notEqual, 's.bigint.notEqual', expected, value);\n}\n\nexport function bigintDivisibleBy(divider: bigint): IConstraint<bigint> {\n\tconst expected = `expected % ${divider}n === 0n`;\n\treturn {\n\t\trun(input: bigint) {\n\t\t\treturn input % divider === 0n //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.bigint.divisibleBy', 'BigInt is not divisible', input, expected));\n\t\t}\n\t};\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\tbigintDivisibleBy,\n\tbigintEqual,\n\tbigintGreaterThan,\n\tbigintGreaterThanOrEqual,\n\tbigintLessThan,\n\tbigintLessThanOrEqual,\n\tbigintNotEqual\n} from '../constraints/BigIntConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class BigIntValidator<T extends bigint> extends BaseValidator<T> {\n\tpublic lessThan(number: bigint): this {\n\t\treturn this.addConstraint(bigintLessThan(number) as IConstraint<T>);\n\t}\n\n\tpublic lessThanOrEqual(number: bigint): this {\n\t\treturn this.addConstraint(bigintLessThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThan(number: bigint): this {\n\t\treturn this.addConstraint(bigintGreaterThan(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThanOrEqual(number: bigint): this {\n\t\treturn this.addConstraint(bigintGreaterThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic equal<N extends bigint>(number: N): BigIntValidator<N> {\n\t\treturn this.addConstraint(bigintEqual(number) as IConstraint<T>) as unknown as BigIntValidator<N>;\n\t}\n\n\tpublic notEqual(number: bigint): this {\n\t\treturn this.addConstraint(bigintNotEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic get positive(): this {\n\t\treturn this.greaterThanOrEqual(0n);\n\t}\n\n\tpublic get negative(): this {\n\t\treturn this.lessThan(0n);\n\t}\n\n\tpublic divisibleBy(number: bigint): this {\n\t\treturn this.addConstraint(bigintDivisibleBy(number) as IConstraint<T>);\n\t}\n\n\tpublic get abs(): this {\n\t\treturn this.transform((value) => (value < 0 ? -value : value) as T);\n\t}\n\n\tpublic intN(bits: number): this {\n\t\treturn this.transform((value) => BigInt.asIntN(bits, value) as T);\n\t}\n\n\tpublic uintN(bits: number): this {\n\t\treturn this.transform((value) => BigInt.asUintN(bits, value) as T);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'bigint' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.bigint', 'Expected a bigint primitive', value));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\n\nexport type BooleanConstraintName = `s.boolean.${boolean}`;\n\nexport const booleanTrue: IConstraint<boolean, true> = {\n\trun(input: boolean) {\n\t\treturn input //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.boolean.true', 'Invalid boolean value', input, 'true'));\n\t}\n};\n\nexport const booleanFalse: IConstraint<boolean, false> = {\n\trun(input: boolean) {\n\t\treturn input //\n\t\t\t? Result.err(new ExpectedConstraintError('s.boolean.false', 'Invalid boolean value', input, 'false'))\n\t\t\t: Result.ok(input);\n\t}\n};\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { booleanFalse, booleanTrue } from '../constraints/BooleanConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class BooleanValidator<T extends boolean = boolean> extends BaseValidator<T> {\n\tpublic get true(): BooleanValidator<true> {\n\t\treturn this.addConstraint(booleanTrue as IConstraint<T>) as BooleanValidator<true>;\n\t}\n\n\tpublic get false(): BooleanValidator<false> {\n\t\treturn this.addConstraint(booleanFalse as IConstraint<T>) as BooleanValidator<false>;\n\t}\n\n\tpublic equal<R extends true | false>(value: R): BooleanValidator<R> {\n\t\treturn (value ? this.true : this.false) as BooleanValidator<R>;\n\t}\n\n\tpublic notEqual<R extends true | false>(value: R): BooleanValidator<R> {\n\t\treturn (value ? this.false : this.true) as BooleanValidator<R>;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'boolean' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.boolean', 'Expected a boolean primitive', value));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type DateConstraintName = `s.date.${\n\t| 'lessThan'\n\t| 'lessThanOrEqual'\n\t| 'greaterThan'\n\t| 'greaterThanOrEqual'\n\t| 'equal'\n\t| 'notEqual'\n\t| 'valid'\n\t| 'invalid'}`;\n\nfunction dateComparator(comparator: Comparator, name: DateConstraintName, expected: string, number: number): IConstraint<Date> {\n\treturn {\n\t\trun(input: Date) {\n\t\t\treturn comparator(input.getTime(), number) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Date value', input, expected));\n\t\t}\n\t};\n}\n\nexport function dateLessThan(value: Date): IConstraint<Date> {\n\tconst expected = `expected < ${value.toISOString()}`;\n\treturn dateComparator(lessThan, 's.date.lessThan', expected, value.getTime());\n}\n\nexport function dateLessThanOrEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected <= ${value.toISOString()}`;\n\treturn dateComparator(lessThanOrEqual, 's.date.lessThanOrEqual', expected, value.getTime());\n}\n\nexport function dateGreaterThan(value: Date): IConstraint<Date> {\n\tconst expected = `expected > ${value.toISOString()}`;\n\treturn dateComparator(greaterThan, 's.date.greaterThan', expected, value.getTime());\n}\n\nexport function dateGreaterThanOrEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected >= ${value.toISOString()}`;\n\treturn dateComparator(greaterThanOrEqual, 's.date.greaterThanOrEqual', expected, value.getTime());\n}\n\nexport function dateEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected === ${value.toISOString()}`;\n\treturn dateComparator(equal, 's.date.equal', expected, value.getTime());\n}\n\nexport function dateNotEqual(value: Date): IConstraint<Date> {\n\tconst expected = `expected !== ${value.toISOString()}`;\n\treturn dateComparator(notEqual, 's.date.notEqual', expected, value.getTime());\n}\n\nexport const dateInvalid: IConstraint<Date> = {\n\trun(input: Date) {\n\t\treturn Number.isNaN(input.getTime()) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.date.invalid', 'Invalid Date value', input, 'expected === NaN'));\n\t}\n};\n\nexport const dateValid: IConstraint<Date> = {\n\trun(input: Date) {\n\t\treturn Number.isNaN(input.getTime()) //\n\t\t\t? Result.err(new ExpectedConstraintError('s.date.valid', 'Invalid Date value', input, 'expected !== NaN'))\n\t\t\t: Result.ok(input);\n\t}\n};\n","import {\n\tdateEqual,\n\tdateGreaterThan,\n\tdateGreaterThanOrEqual,\n\tdateInvalid,\n\tdateLessThan,\n\tdateLessThanOrEqual,\n\tdateNotEqual,\n\tdateValid\n} from '../constraints/DateConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class DateValidator extends BaseValidator<Date> {\n\tpublic lessThan(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateLessThan(new Date(date)));\n\t}\n\n\tpublic lessThanOrEqual(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateLessThanOrEqual(new Date(date)));\n\t}\n\n\tpublic greaterThan(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateGreaterThan(new Date(date)));\n\t}\n\n\tpublic greaterThanOrEqual(date: Date | number | string): this {\n\t\treturn this.addConstraint(dateGreaterThanOrEqual(new Date(date)));\n\t}\n\n\tpublic equal(date: Date | number | string): this {\n\t\tconst resolved = new Date(date);\n\t\treturn Number.isNaN(resolved.getTime()) //\n\t\t\t? this.invalid\n\t\t\t: this.addConstraint(dateEqual(resolved));\n\t}\n\n\tpublic notEqual(date: Date | number | string): this {\n\t\tconst resolved = new Date(date);\n\t\treturn Number.isNaN(resolved.getTime()) //\n\t\t\t? this.valid\n\t\t\t: this.addConstraint(dateNotEqual(resolved));\n\t}\n\n\tpublic get valid(): this {\n\t\treturn this.addConstraint(dateValid);\n\t}\n\n\tpublic get invalid(): this {\n\t\treturn this.addConstraint(dateInvalid);\n\t}\n\n\tprotected handle(value: unknown): Result<Date, ValidationError> {\n\t\treturn value instanceof Date //\n\t\t\t? Result.ok(value)\n\t\t\t: Result.err(new ValidationError('s.date', 'Expected a Date', value));\n\t}\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { customInspectSymbolStackLess } from './BaseError';\nimport { ValidationError } from './ValidationError';\n\nexport class ExpectedValidationError<T> extends ValidationError {\n\tpublic readonly expected: T;\n\n\tpublic constructor(validator: string, message: string, given: unknown, expected: T) {\n\t\tsuper(validator, message, given);\n\t\tthis.expected = expected;\n\t}\n\n\tpublic override toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tvalidator: this.validator,\n\t\t\tgiven: this.given,\n\t\t\texpected: this.expected\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst validator = options.stylize(this.validator, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[ExpectedValidationError: ${validator}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1 };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst expected = inspect(this.expected, newOptions).replace(/\\n/g, padding);\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('ExpectedValidationError', 'special')} > ${validator}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst expectedBlock = `\\n ${options.stylize('Expected:', 'string')}${padding}${expected}`;\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${expectedBlock}\\n${givenBlock}`;\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { ExpectedValidationError } from '../lib/errors/ExpectedValidationError';\nimport { Result } from '../lib/Result';\nimport type { Constructor } from '../lib/util-types';\nimport { BaseValidator } from './imports';\n\nexport class InstanceValidator<T> extends BaseValidator<T> {\n\tpublic readonly expected: Constructor<T>;\n\n\tpublic constructor(expected: Constructor<T>, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.expected = expected;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ExpectedValidationError<Constructor<T>>> {\n\t\treturn value instanceof this.expected //\n\t\t\t? Result.ok(value)\n\t\t\t: Result.err(new ExpectedValidationError('s.instance(V)', 'Expected', value, this.expected));\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.expected, this.constraints]);\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { ExpectedValidationError } from '../lib/errors/ExpectedValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class LiteralValidator<T> extends BaseValidator<T> {\n\tpublic readonly expected: T;\n\n\tpublic constructor(literal: T, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.expected = literal;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ExpectedValidationError<T>> {\n\t\treturn Object.is(value, this.expected) //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ExpectedValidationError('s.literal(V)', 'Expected values to be equals', value, this.expected));\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.expected, this.constraints]);\n\t}\n}\n","import { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NeverValidator extends BaseValidator<never> {\n\tprotected handle(value: unknown): Result<never, ValidationError> {\n\t\treturn Result.err(new ValidationError('s.never', 'Expected a value to not be passed', value));\n\t}\n}\n","import { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NullishValidator extends BaseValidator<undefined | null> {\n\tprotected handle(value: unknown): Result<undefined | null, ValidationError> {\n\t\treturn value === undefined || value === null //\n\t\t\t? Result.ok(value)\n\t\t\t: Result.err(new ValidationError('s.nullish', 'Expected undefined or null', value));\n\t}\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\n\nexport type NumberConstraintName = `s.number.${\n\t| 'lessThan'\n\t| 'lessThanOrEqual'\n\t| 'greaterThan'\n\t| 'greaterThanOrEqual'\n\t| 'equal'\n\t| 'equal(NaN)'\n\t| 'notEqual'\n\t| 'notEqual(NaN)'\n\t| 'int'\n\t| 'safeInt'\n\t| 'finite'\n\t| 'divisibleBy'}`;\n\nfunction numberComparator(comparator: Comparator, name: NumberConstraintName, expected: string, number: number): IConstraint<number> {\n\treturn {\n\t\trun(input: number) {\n\t\t\treturn comparator(input, number) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid number value', input, expected));\n\t\t}\n\t};\n}\n\nexport function numberLessThan(value: number): IConstraint<number> {\n\tconst expected = `expected < ${value}`;\n\treturn numberComparator(lessThan, 's.number.lessThan', expected, value);\n}\n\nexport function numberLessThanOrEqual(value: number): IConstraint<number> {\n\tconst expected = `expected <= ${value}`;\n\treturn numberComparator(lessThanOrEqual, 's.number.lessThanOrEqual', expected, value);\n}\n\nexport function numberGreaterThan(value: number): IConstraint<number> {\n\tconst expected = `expected > ${value}`;\n\treturn numberComparator(greaterThan, 's.number.greaterThan', expected, value);\n}\n\nexport function numberGreaterThanOrEqual(value: number): IConstraint<number> {\n\tconst expected = `expected >= ${value}`;\n\treturn numberComparator(greaterThanOrEqual, 's.number.greaterThanOrEqual', expected, value);\n}\n\nexport function numberEqual(value: number): IConstraint<number> {\n\tconst expected = `expected === ${value}`;\n\treturn numberComparator(equal, 's.number.equal', expected, value);\n}\n\nexport function numberNotEqual(value: number): IConstraint<number> {\n\tconst expected = `expected !== ${value}`;\n\treturn numberComparator(notEqual, 's.number.notEqual', expected, value);\n}\n\nexport const numberInt: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isInteger(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(\n\t\t\t\t\tnew ExpectedConstraintError('s.number.int', 'Given value is not an integer', input, 'Number.isInteger(expected) to be true')\n\t\t\t );\n\t}\n};\n\nexport const numberSafeInt: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isSafeInteger(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(\n\t\t\t\t\tnew ExpectedConstraintError(\n\t\t\t\t\t\t's.number.safeInt',\n\t\t\t\t\t\t'Given value is not a safe integer',\n\t\t\t\t\t\tinput,\n\t\t\t\t\t\t'Number.isSafeInteger(expected) to be true'\n\t\t\t\t\t)\n\t\t\t );\n\t}\n};\n\nexport const numberFinite: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isFinite(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.number.finite', 'Given value is not finite', input, 'Number.isFinite(expected) to be true'));\n\t}\n};\n\nexport const numberNaN: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isNaN(input) //\n\t\t\t? Result.ok(input)\n\t\t\t: Result.err(new ExpectedConstraintError('s.number.equal(NaN)', 'Invalid number value', input, 'expected === NaN'));\n\t}\n};\n\nexport const numberNotNaN: IConstraint<number> = {\n\trun(input: number) {\n\t\treturn Number.isNaN(input) //\n\t\t\t? Result.err(new ExpectedConstraintError('s.number.notEqual(NaN)', 'Invalid number value', input, 'expected !== NaN'))\n\t\t\t: Result.ok(input);\n\t}\n};\n\nexport function numberDivisibleBy(divider: number): IConstraint<number> {\n\tconst expected = `expected % ${divider} === 0`;\n\treturn {\n\t\trun(input: number) {\n\t\t\treturn input % divider === 0 //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.number.divisibleBy', 'Number is not divisible', input, expected));\n\t\t}\n\t};\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\tnumberDivisibleBy,\n\tnumberEqual,\n\tnumberFinite,\n\tnumberGreaterThan,\n\tnumberGreaterThanOrEqual,\n\tnumberInt,\n\tnumberLessThan,\n\tnumberLessThanOrEqual,\n\tnumberNaN,\n\tnumberNotEqual,\n\tnumberNotNaN,\n\tnumberSafeInt\n} from '../constraints/NumberConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NumberValidator<T extends number> extends BaseValidator<T> {\n\tpublic lessThan(number: number): this {\n\t\treturn this.addConstraint(numberLessThan(number) as IConstraint<T>);\n\t}\n\n\tpublic lessThanOrEqual(number: number): this {\n\t\treturn this.addConstraint(numberLessThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThan(number: number): this {\n\t\treturn this.addConstraint(numberGreaterThan(number) as IConstraint<T>);\n\t}\n\n\tpublic greaterThanOrEqual(number: number): this {\n\t\treturn this.addConstraint(numberGreaterThanOrEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic equal<N extends number>(number: N): NumberValidator<N> {\n\t\treturn Number.isNaN(number) //\n\t\t\t? (this.addConstraint(numberNaN as IConstraint<T>) as unknown as NumberValidator<N>)\n\t\t\t: (this.addConstraint(numberEqual(number) as IConstraint<T>) as unknown as NumberValidator<N>);\n\t}\n\n\tpublic notEqual(number: number): this {\n\t\treturn Number.isNaN(number) //\n\t\t\t? this.addConstraint(numberNotNaN as IConstraint<T>)\n\t\t\t: this.addConstraint(numberNotEqual(number) as IConstraint<T>);\n\t}\n\n\tpublic get int(): this {\n\t\treturn this.addConstraint(numberInt as IConstraint<T>);\n\t}\n\n\tpublic get safeInt(): this {\n\t\treturn this.addConstraint(numberSafeInt as IConstraint<T>);\n\t}\n\n\tpublic get finite(): this {\n\t\treturn this.addConstraint(numberFinite as IConstraint<T>);\n\t}\n\n\tpublic get positive(): this {\n\t\treturn this.greaterThanOrEqual(0);\n\t}\n\n\tpublic get negative(): this {\n\t\treturn this.lessThan(0);\n\t}\n\n\tpublic divisibleBy(divider: number): this {\n\t\treturn this.addConstraint(numberDivisibleBy(divider) as IConstraint<T>);\n\t}\n\n\tpublic get abs(): this {\n\t\treturn this.transform(Math.abs as (value: number) => T);\n\t}\n\n\tpublic get sign(): this {\n\t\treturn this.transform(Math.sign as (value: number) => T);\n\t}\n\n\tpublic get trunc(): this {\n\t\treturn this.transform(Math.trunc as (value: number) => T);\n\t}\n\n\tpublic get floor(): this {\n\t\treturn this.transform(Math.floor as (value: number) => T);\n\t}\n\n\tpublic get fround(): this {\n\t\treturn this.transform(Math.fround as (value: number) => T);\n\t}\n\n\tpublic get round(): this {\n\t\treturn this.transform(Math.round as (value: number) => T);\n\t}\n\n\tpublic get ceil(): this {\n\t\treturn this.transform(Math.ceil as (value: number) => T);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'number' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.number', 'Expected a number primitive', value));\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class MissingPropertyError extends BaseError {\n\tpublic readonly property: PropertyKey;\n\n\tpublic constructor(property: PropertyKey) {\n\t\tsuper('A required property is missing');\n\t\tthis.property = property;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tproperty: this.property\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst property = options.stylize(this.property.toString(), 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[MissingPropertyError: ${property}]`, 'special');\n\t\t}\n\n\t\tconst header = `${options.stylize('MissingPropertyError', 'special')} > ${property}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\treturn `${header}\\n ${message}`;\n\t}\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class UnknownPropertyError extends BaseError {\n\tpublic readonly property: PropertyKey;\n\tpublic readonly value: unknown;\n\n\tpublic constructor(property: PropertyKey, value: unknown) {\n\t\tsuper('Received unexpected property');\n\n\t\tthis.property = property;\n\t\tthis.value = value;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tproperty: this.property,\n\t\t\tvalue: this.value\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst property = options.stylize(this.property.toString(), 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[UnknownPropertyError: ${property}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst given = inspect(this.value, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('UnknownPropertyError', 'special')} > ${property}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${givenBlock}`;\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport { Result } from '../lib/Result';\nimport type { ValidatorError } from './BaseValidator';\nimport { BaseValidator } from './imports';\nimport { getValue } from './util/getValue';\n\nexport class DefaultValidator<T> extends BaseValidator<T> {\n\tprivate readonly validator: BaseValidator<T>;\n\tprivate defaultValue: T | (() => T);\n\n\tpublic constructor(validator: BaseValidator<T>, value: T | (() => T), constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t\tthis.defaultValue = value;\n\t}\n\n\tpublic override default(value: Exclude<T, undefined> | (() => Exclude<T, undefined>)): DefaultValidator<Exclude<T, undefined>> {\n\t\tconst clone = this.clone() as unknown as DefaultValidator<Exclude<T, undefined>>;\n\t\tclone.defaultValue = value;\n\t\treturn clone;\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidatorError> {\n\t\treturn typeof value === 'undefined' //\n\t\t\t? Result.ok(getValue(this.defaultValue))\n\t\t\t: this.validator['handle'](value); // eslint-disable-line @typescript-eslint/dot-notation\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.defaultValue, this.constraints]);\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class CombinedError extends BaseError {\n\tpublic readonly errors: readonly BaseError[];\n\n\tpublic constructor(errors: readonly BaseError[]) {\n\t\tsuper('Received one or more errors');\n\n\t\tthis.errors = errors;\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize('[CombinedError]', 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1, compact: true };\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\n\t\tconst header = `${options.stylize('CombinedError', 'special')} (${options.stylize(this.errors.length.toString(), 'number')})`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst errors = this.errors\n\t\t\t.map((error, i) => {\n\t\t\t\tconst index = options.stylize((i + 1).toString(), 'number');\n\t\t\t\tconst body = error[customInspectSymbolStackLess](depth - 1, newOptions).replace(/\\n/g, padding);\n\n\t\t\t\treturn ` ${index} ${body}`;\n\t\t\t})\n\t\t\t.join('\\n\\n');\n\t\treturn `${header}\\n ${message}\\n\\n${errors}`;\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedError } from '../lib/errors/CombinedError';\nimport type { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator, LiteralValidator, NullishValidator } from './imports';\n\nexport class UnionValidator<T> extends BaseValidator<T> {\n\tprivate validators: readonly BaseValidator<T>[];\n\n\tpublic constructor(validators: readonly BaseValidator<T>[], constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validators = validators;\n\t}\n\n\tpublic override get optional(): UnionValidator<T | undefined> {\n\t\tif (this.validators.length === 0) return new UnionValidator<T | undefined>([new LiteralValidator(undefined)], this.constraints);\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\t// If already optional, return a clone:\n\t\t\tif (validator.expected === undefined) return this.clone();\n\n\t\t\t// If it's nullable, convert the nullable validator into a nullish validator to optimize `null | undefined`:\n\t\t\tif (validator.expected === null) {\n\t\t\t\treturn new UnionValidator<T | null | undefined>(\n\t\t\t\t\t[new NullishValidator(), ...this.validators.slice(1)],\n\t\t\t\t\tthis.constraints\n\t\t\t\t) as UnionValidator<T | undefined>;\n\t\t\t}\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t// If it's already nullish (which validates optional), return a clone:\n\t\t\treturn this.clone();\n\t\t}\n\n\t\treturn new UnionValidator([new LiteralValidator(undefined), ...this.validators]);\n\t}\n\n\tpublic get required(): UnionValidator<Exclude<T, undefined>> {\n\t\ttype RequiredValidator = UnionValidator<Exclude<T, undefined>>;\n\n\t\tif (this.validators.length === 0) return this.clone() as unknown as RequiredValidator;\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\tif (validator.expected === undefined) return new UnionValidator(this.validators.slice(1), this.constraints) as RequiredValidator;\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\treturn new UnionValidator([new LiteralValidator(null), ...this.validators.slice(1)], this.constraints) as RequiredValidator;\n\t\t}\n\n\t\treturn this.clone() as unknown as RequiredValidator;\n\t}\n\n\tpublic override get nullable(): UnionValidator<T | null> {\n\t\tif (this.validators.length === 0) return new UnionValidator<T | null>([new LiteralValidator(null)], this.constraints);\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\t// If already nullable, return a clone:\n\t\t\tif (validator.expected === null) return this.clone();\n\n\t\t\t// If it's optional, convert the optional validator into a nullish validator to optimize `null | undefined`:\n\t\t\tif (validator.expected === undefined) {\n\t\t\t\treturn new UnionValidator<T | null | undefined>(\n\t\t\t\t\t[new NullishValidator(), ...this.validators.slice(1)],\n\t\t\t\t\tthis.constraints\n\t\t\t\t) as UnionValidator<T | null>;\n\t\t\t}\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t// If it's already nullish (which validates nullable), return a clone:\n\t\t\treturn this.clone();\n\t\t}\n\n\t\treturn new UnionValidator([new LiteralValidator(null), ...this.validators]);\n\t}\n\n\tpublic override get nullish(): UnionValidator<T | null | undefined> {\n\t\tif (this.validators.length === 0) return new UnionValidator<T | null | undefined>([new NullishValidator()], this.constraints);\n\n\t\tconst [validator] = this.validators;\n\t\tif (validator instanceof LiteralValidator) {\n\t\t\t// If already nullable or optional, promote the union to nullish:\n\t\t\tif (validator.expected === null || validator.expected === undefined) {\n\t\t\t\treturn new UnionValidator<T | null | undefined>([new NullishValidator(), ...this.validators.slice(1)], this.constraints);\n\t\t\t}\n\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t// If it's already nullish, return a clone:\n\t\t\treturn this.clone();\n\t\t}\n\n\t\treturn new UnionValidator<T | null | undefined>([new NullishValidator(), ...this.validators]);\n\t}\n\n\tpublic override or<O>(...predicates: readonly BaseValidator<O>[]): UnionValidator<T | O> {\n\t\treturn new UnionValidator<T | O>([...this.validators, ...predicates]);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validators, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError | CombinedError> {\n\t\tconst errors: BaseError[] = [];\n\n\t\tfor (const validator of this.validators) {\n\t\t\tconst result = validator.run(value);\n\t\t\tif (result.isOk()) return result as Result<T, CombinedError>;\n\t\t\terrors.push(result.error!);\n\t\t}\n\n\t\treturn Result.err(new CombinedError(errors));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { MissingPropertyError } from '../lib/errors/MissingPropertyError';\nimport { UnknownPropertyError } from '../lib/errors/UnknownPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport type { MappedObjectValidator, UndefinedToOptional } from '../lib/util-types';\nimport { BaseValidator } from './BaseValidator';\nimport { DefaultValidator } from './DefaultValidator';\nimport { LiteralValidator } from './LiteralValidator';\nimport { NullishValidator } from './NullishValidator';\nimport { UnionValidator } from './UnionValidator';\n\nexport class ObjectValidator<T extends object, I = UndefinedToOptional<T>> extends BaseValidator<I> {\n\tpublic readonly shape: MappedObjectValidator<T>;\n\tpublic readonly strategy: ObjectValidatorStrategy;\n\tprivate readonly keys: readonly (keyof I)[] = [];\n\tprivate readonly handleStrategy: (value: object) => Result<I, CombinedPropertyError>;\n\n\tprivate readonly requiredKeys = new Map<keyof I, BaseValidator<unknown>>();\n\tprivate readonly possiblyUndefinedKeys = new Map<keyof I, BaseValidator<unknown>>();\n\tprivate readonly possiblyUndefinedKeysWithDefaults = new Map<keyof I, DefaultValidator<unknown>>();\n\n\tpublic constructor(\n\t\tshape: MappedObjectValidator<T>,\n\t\tstrategy: ObjectValidatorStrategy = ObjectValidatorStrategy.Ignore,\n\t\tconstraints: readonly IConstraint<I>[] = []\n\t) {\n\t\tsuper(constraints);\n\t\tthis.shape = shape;\n\t\tthis.strategy = strategy;\n\n\t\tswitch (this.strategy) {\n\t\t\tcase ObjectValidatorStrategy.Ignore:\n\t\t\t\tthis.handleStrategy = (value) => this.handleIgnoreStrategy(value);\n\t\t\t\tbreak;\n\t\t\tcase ObjectValidatorStrategy.Strict: {\n\t\t\t\tthis.handleStrategy = (value) => this.handleStrictStrategy(value);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase ObjectValidatorStrategy.Passthrough:\n\t\t\t\tthis.handleStrategy = (value) => this.handlePassthroughStrategy(value);\n\t\t\t\tbreak;\n\t\t}\n\n\t\tconst shapeEntries = Object.entries(shape) as [keyof I, BaseValidator<T>][];\n\t\tthis.keys = shapeEntries.map(([key]) => key);\n\n\t\tfor (const [key, validator] of shapeEntries) {\n\t\t\tif (validator instanceof UnionValidator) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/dot-notation\n\t\t\t\tconst [possiblyLiteralOrNullishPredicate] = validator['validators'];\n\n\t\t\t\tif (possiblyLiteralOrNullishPredicate instanceof NullishValidator) {\n\t\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t\t} else if (possiblyLiteralOrNullishPredicate instanceof LiteralValidator) {\n\t\t\t\t\tif (possiblyLiteralOrNullishPredicate.expected === undefined) {\n\t\t\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t\t\t}\n\t\t\t\t} else if (validator instanceof DefaultValidator) {\n\t\t\t\t\tthis.possiblyUndefinedKeysWithDefaults.set(key, validator);\n\t\t\t\t} else {\n\t\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t\t}\n\t\t\t} else if (validator instanceof NullishValidator) {\n\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t} else if (validator instanceof LiteralValidator) {\n\t\t\t\tif (validator.expected === undefined) {\n\t\t\t\t\tthis.possiblyUndefinedKeys.set(key, validator);\n\t\t\t\t} else {\n\t\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t\t}\n\t\t\t} else if (validator instanceof DefaultValidator) {\n\t\t\t\tthis.possiblyUndefinedKeysWithDefaults.set(key, validator);\n\t\t\t} else {\n\t\t\t\tthis.requiredKeys.set(key, validator);\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic get strict(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, ObjectValidatorStrategy.Strict, this.constraints]);\n\t}\n\n\tpublic get ignore(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, ObjectValidatorStrategy.Ignore, this.constraints]);\n\t}\n\n\tpublic get passthrough(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, ObjectValidatorStrategy.Passthrough, this.constraints]);\n\t}\n\n\tpublic get partial(): ObjectValidator<{ [Key in keyof I]?: I[Key] }> {\n\t\tconst shape = Object.fromEntries(this.keys.map((key) => [key, this.shape[key as unknown as keyof typeof this.shape].optional]));\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic get required(): ObjectValidator<{ [Key in keyof I]-?: I[Key] }> {\n\t\tconst shape = Object.fromEntries(\n\t\t\tthis.keys.map((key) => {\n\t\t\t\tlet validator = this.shape[key as unknown as keyof typeof this.shape];\n\t\t\t\tif (validator instanceof UnionValidator) validator = validator.required;\n\t\t\t\treturn [key, validator];\n\t\t\t})\n\t\t);\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic extend<ET extends object>(schema: ObjectValidator<ET> | MappedObjectValidator<ET>): ObjectValidator<T & ET> {\n\t\tconst shape = { ...this.shape, ...(schema instanceof ObjectValidator ? schema.shape : schema) };\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic pick<K extends keyof I>(keys: readonly K[]): ObjectValidator<{ [Key in keyof Pick<I, K>]: I[Key] }> {\n\t\tconst shape = Object.fromEntries(\n\t\t\tkeys.filter((key) => this.keys.includes(key)).map((key) => [key, this.shape[key as unknown as keyof typeof this.shape]])\n\t\t);\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tpublic omit<K extends keyof I>(keys: readonly K[]): ObjectValidator<{ [Key in keyof Omit<I, K>]: I[Key] }> {\n\t\tconst shape = Object.fromEntries(\n\t\t\tthis.keys.filter((key) => !keys.includes(key as any)).map((key) => [key, this.shape[key as unknown as keyof typeof this.shape]])\n\t\t);\n\t\treturn Reflect.construct(this.constructor, [shape, this.strategy, this.constraints]);\n\t}\n\n\tprotected override handle(value: unknown): Result<I, ValidationError | CombinedPropertyError> {\n\t\tconst typeOfValue = typeof value;\n\t\tif (typeOfValue !== 'object') {\n\t\t\treturn Result.err(new ValidationError('s.object(T)', `Expected the value to be an object, but received ${typeOfValue} instead`, value));\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn Result.err(new ValidationError('s.object(T)', 'Expected the value to not be null', value));\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\treturn Result.err(new ValidationError('s.object(T)', 'Expected the value to not be an array', value));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(value as I);\n\t\t}\n\n\t\tfor (const predicate of Object.values(this.shape) as BaseValidator<any>[]) {\n\t\t\tpredicate.setParent(this.parent ?? value!);\n\t\t}\n\n\t\treturn this.handleStrategy(value as object);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.shape, this.strategy, this.constraints]);\n\t}\n\n\tprivate handleIgnoreStrategy(value: object): Result<I, CombinedPropertyError> {\n\t\tconst errors: [PropertyKey, BaseError][] = [];\n\t\tconst finalObject = {} as I;\n\t\tconst inputEntries = new Map(Object.entries(value) as [keyof I, unknown][]);\n\n\t\tconst runPredicate = (key: keyof I, predicate: BaseValidator<unknown>) => {\n\t\t\tconst result = predicate.run(value[key as keyof object]);\n\n\t\t\tif (result.isOk()) {\n\t\t\t\tfinalObject[key] = result.value as I[keyof I];\n\t\t\t} else {\n\t\t\t\tconst error = result.error!;\n\t\t\t\terrors.push([key, error]);\n\t\t\t}\n\t\t};\n\n\t\tfor (const [key, predicate] of this.requiredKeys) {\n\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\trunPredicate(key, predicate);\n\t\t\t} else {\n\t\t\t\terrors.push([key, new MissingPropertyError(key)]);\n\t\t\t}\n\t\t}\n\n\t\t// Run possibly undefined keys that also have defaults even if there are no more keys to process (this is necessary so we fill in those defaults)\n\t\tfor (const [key, validator] of this.possiblyUndefinedKeysWithDefaults) {\n\t\t\tinputEntries.delete(key);\n\t\t\trunPredicate(key, validator);\n\t\t}\n\n\t\t// Early exit if there are no more properties to validate in the object and there are errors to report\n\t\tif (inputEntries.size === 0) {\n\t\t\treturn errors.length === 0 //\n\t\t\t\t? Result.ok(finalObject)\n\t\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t\t}\n\n\t\t// In the event the remaining keys to check are less than the number of possible undefined keys, we check those\n\t\t// as it could yield a faster execution\n\t\tconst checkInputEntriesInsteadOfSchemaKeys = this.possiblyUndefinedKeys.size > inputEntries.size;\n\n\t\tif (checkInputEntriesInsteadOfSchemaKeys) {\n\t\t\tfor (const [key] of inputEntries) {\n\t\t\t\tconst predicate = this.possiblyUndefinedKeys.get(key);\n\n\t\t\t\tif (predicate) {\n\t\t\t\t\trunPredicate(key, predicate);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor (const [key, predicate] of this.possiblyUndefinedKeys) {\n\t\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\t\trunPredicate(key, predicate);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(finalObject)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n\n\tprivate handleStrictStrategy(value: object): Result<I, CombinedPropertyError> {\n\t\tconst errors: [PropertyKey, BaseError][] = [];\n\t\tconst finalResult = {} as I;\n\t\tconst inputEntries = new Map(Object.entries(value) as [keyof I, unknown][]);\n\n\t\tconst runPredicate = (key: keyof I, predicate: BaseValidator<unknown>) => {\n\t\t\tconst result = predicate.run(value[key as keyof object]);\n\n\t\t\tif (result.isOk()) {\n\t\t\t\tfinalResult[key] = result.value as I[keyof I];\n\t\t\t} else {\n\t\t\t\tconst error = result.error!;\n\t\t\t\terrors.push([key, error]);\n\t\t\t}\n\t\t};\n\n\t\tfor (const [key, predicate] of this.requiredKeys) {\n\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\trunPredicate(key, predicate);\n\t\t\t} else {\n\t\t\t\terrors.push([key, new MissingPropertyError(key)]);\n\t\t\t}\n\t\t}\n\n\t\t// Run possibly undefined keys that also have defaults even if there are no more keys to process (this is necessary so we fill in those defaults)\n\t\tfor (const [key, validator] of this.possiblyUndefinedKeysWithDefaults) {\n\t\t\tinputEntries.delete(key);\n\t\t\trunPredicate(key, validator);\n\t\t}\n\n\t\tfor (const [key, predicate] of this.possiblyUndefinedKeys) {\n\t\t\t// All of these validators are assumed to be possibly undefined, so if we have gone through the entire object and there's still validators,\n\t\t\t// safe to assume we're done here\n\t\t\tif (inputEntries.size === 0) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tif (inputEntries.delete(key)) {\n\t\t\t\trunPredicate(key, predicate);\n\t\t\t}\n\t\t}\n\n\t\tif (inputEntries.size !== 0) {\n\t\t\tfor (const [key, value] of inputEntries.entries()) {\n\t\t\t\terrors.push([key, new UnknownPropertyError(key, value)]);\n\t\t\t}\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(finalResult)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n\n\tprivate handlePassthroughStrategy(value: object): Result<I, CombinedPropertyError> {\n\t\tconst result = this.handleIgnoreStrategy(value);\n\t\treturn result.isErr() ? result : Result.ok({ ...value, ...result.value } as I);\n\t}\n}\n\nexport enum ObjectValidatorStrategy {\n\tIgnore,\n\tStrict,\n\tPassthrough\n}\n","import type { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class PassthroughValidator<T extends any | unknown> extends BaseValidator<T> {\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn Result.ok(value as T);\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class RecordValidator<T> extends BaseValidator<Record<string, T>> {\n\tprivate readonly validator: BaseValidator<T>;\n\n\tpublic constructor(validator: BaseValidator<T>, constraints: readonly IConstraint<Record<string, T>>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<Record<string, T>, ValidationError | CombinedPropertyError> {\n\t\tif (typeof value !== 'object') {\n\t\t\treturn Result.err(new ValidationError('s.record(T)', 'Expected an object', value));\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn Result.err(new ValidationError('s.record(T)', 'Expected the value to not be null', value));\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\treturn Result.err(new ValidationError('s.record(T)', 'Expected the value to not be an array', value));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(value as Record<string, T>);\n\t\t}\n\n\t\tconst errors: [string, BaseError][] = [];\n\t\tconst transformed: Record<string, T> = {};\n\n\t\tfor (const [key, val] of Object.entries(value!)) {\n\t\t\tconst result = this.validator.run(val);\n\t\t\tif (result.isOk()) transformed[key] = result.value;\n\t\t\telse errors.push([key, result.error!]);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedError } from '../lib/errors/CombinedError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class SetValidator<T> extends BaseValidator<Set<T>> {\n\tprivate readonly validator: BaseValidator<T>;\n\n\tpublic constructor(validator: BaseValidator<T>, constraints: readonly IConstraint<Set<T>>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<Set<T>, ValidationError | CombinedError> {\n\t\tif (!(values instanceof Set)) {\n\t\t\treturn Result.err(new ValidationError('s.set(T)', 'Expected a set', values));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(values);\n\t\t}\n\n\t\tconst errors: BaseError[] = [];\n\t\tconst transformed = new Set<T>();\n\n\t\tfor (const value of values) {\n\t\t\tconst result = this.validator.run(value);\n\t\t\tif (result.isOk()) transformed.add(result.value);\n\t\t\telse errors.push(result.error!);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedError(errors));\n\t}\n}\n","/**\n * [RFC-5322](https://datatracker.ietf.org/doc/html/rfc5322)\n * compliant {@link RegExp} to validate an email address\n *\n * @see https://stackoverflow.com/questions/201323/how-can-i-validate-an-email-address-using-a-regular-expression/201378#201378\n */\nconst accountRegex =\n\t/^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")$/;\n\n/**\n * Validates an email address string based on various checks:\n * - It must be a non nullish and non empty string\n * - It must include at least an `@` symbol`\n * - The account name may not exceed 64 characters\n * - The domain name may not exceed 255 characters\n * - The domain must include at least one `.` symbol\n * - Each part of the domain, split by `.` must not exceed 63 characters\n * - The email address must be [RFC-5322](https://datatracker.ietf.org/doc/html/rfc5322) compliant\n * @param email The email to validate\n * @returns `true` if the email is valid, `false` otherwise\n *\n * @remark Based on the following sources:\n * - `email-validator` by [manisharaan](https://github.com/manishsaraan) ([code](https://github.com/manishsaraan/email-validator/blob/master/index.js))\n * - [Comparing E-mail Address Validating Regular Expressions](http://fightingforalostcause.net/misc/2006/compare-email-regex.php)\n * - [Validating Email Addresses by Derrick Pallas](http://thedailywtf.com/Articles/Validating_Email_Addresses.aspx)\n * - [StackOverflow answer by bortzmeyer](http://stackoverflow.com/questions/201323/what-is-the-best-regular-expression-for-validating-email-addresses/201378#201378)\n * - [The wikipedia page on Email addresses](https://en.wikipedia.org/wiki/Email_address)\n */\nexport function validateEmail(email: string): boolean {\n\t// 1. Non-nullish and non-empty string check.\n\t//\n\t// If a nullish or empty email was provided then do an early exit\n\tif (!email) return false;\n\n\t// Find the location of the @ symbol:\n\tconst atIndex = email.indexOf('@');\n\n\t// 2. @ presence check.\n\t//\n\t// If the email does not have the @ symbol, it's automatically invalid:\n\tif (atIndex === -1) return false;\n\n\t// 3. <account> maximum length check.\n\t//\n\t// From <account>@<domain>, if <account> exceeds 64 characters, then the\n\t// position of the @ symbol is 64 or greater. In this case, the email is\n\t// invalid:\n\tif (atIndex > 64) return false;\n\n\tconst domainIndex = atIndex + 1;\n\n\t// 7.1. Duplicated @ symbol check.\n\t//\n\t// If there's a second @ symbol, the email is automatically invalid:\n\tif (email.includes('@', domainIndex)) return false;\n\n\t// 4. <domain> maximum length check.\n\t//\n\t// From <account>@<domain>, if <domain> exceeds 255 characters, then it\n\t// means that the amount of characters between the start of <domain> and the\n\t// end of the string is separated by 255 or more characters.\n\tif (email.length - domainIndex > 255) return false;\n\n\t// Find the location of the . symbol in <domain>:\n\tlet dotIndex = email.indexOf('.', domainIndex);\n\n\t// 5. <domain> dot (.) symbol check.\n\t//\n\t// From <account>@<domain>, if <domain> does not contain a dot (.) symbol,\n\t// then it means the domain is invalid.\n\tif (dotIndex === -1) return false;\n\n\t// 6. <domain> parts length.\n\t//\n\t// Assign a temporary variable to store the start of the last read domain\n\t// part, this would be at the start of <domain>.\n\t//\n\t// For a <domain> part to be correct, it must have at most, 63 characters.\n\t// We repeat this step for every sub-section of <domain> contained within\n\t// dot (.) symbols.\n\t//\n\t// The following step is a more optimized version of the following code:\n\t//\n\t// ```javascript\n\t// domain.split('.').some((part) => part.length > 63);\n\t// ```\n\tlet lastDotIndex = domainIndex;\n\tdo {\n\t\tif (dotIndex - lastDotIndex > 63) return false;\n\n\t\tlastDotIndex = dotIndex + 1;\n\t} while ((dotIndex = email.indexOf('.', lastDotIndex)) !== -1);\n\n\t// The loop iterates from the first to the n - 1 part, this line checks for\n\t// the last (n) part:\n\tif (email.length - lastDotIndex > 63) return false;\n\n\t// 7.2. Character checks.\n\t//\n\t// From <account>@<domain>:\n\t// - Extract the <account> part by slicing the input from start to the @\n\t// character. Validate afterwards.\n\t// - Extract the <domain> part by slicing the input from the start of\n\t// <domain>. Validate afterwards.\n\t//\n\t// Note: we inline the variables so <domain> isn't created unless the\n\t// <account> check passes.\n\treturn accountRegex.test(email.slice(0, atIndex)) && validateEmailDomain(email.slice(domainIndex));\n}\n\nfunction validateEmailDomain(domain: string): boolean {\n\ttry {\n\t\treturn new URL(`http://${domain}`).hostname === domain;\n\t} catch {\n\t\treturn false;\n\t}\n}\n","/**\n * Code ported from https://github.com/nodejs/node/blob/5fad0b93667ffc6e4def52996b9529ac99b26319/lib/internal/net.js\n */\n\n// IPv4 Segment\nconst v4Seg = '(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])';\nconst v4Str = `(${v4Seg}[.]){3}${v4Seg}`;\nconst IPv4Reg = new RegExp(`^${v4Str}$`);\n\n// IPv6 Segment\nconst v6Seg = '(?:[0-9a-fA-F]{1,4})';\nconst IPv6Reg = new RegExp(\n\t'^(' +\n\t\t`(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +\n\t\t`(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +\n\t\t`(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` +\n\t\t`(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` +\n\t\t`(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` +\n\t\t`(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` +\n\t\t`(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` +\n\t\t`(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +\n\t\t')(%[0-9a-zA-Z-.:]{1,})?$'\n);\n\nexport function isIPv4(s: string): boolean {\n\treturn IPv4Reg.test(s);\n}\n\nexport function isIPv6(s: string): boolean {\n\treturn IPv6Reg.test(s);\n}\n\nexport function isIP(s: string): number {\n\tif (isIPv4(s)) return 4;\n\tif (isIPv6(s)) return 6;\n\treturn 0;\n}\n","export const phoneNumberRegex = /^((?:\\+|0{0,2})\\d{1,2}\\s?)?\\(?\\d{3}\\)?[\\s.-]?\\d{3}[\\s.-]?\\d{4}$/;\n\nexport function validatePhoneNumber(input: string) {\n\treturn phoneNumberRegex.test(input);\n}\n","import { inspect, type InspectOptionsStylized } from 'util';\nimport { customInspectSymbolStackLess } from './BaseError';\nimport { BaseConstraintError, type ConstraintErrorNames } from './BaseConstraintError';\n\nexport class MultiplePossibilitiesConstraintError<T = unknown> extends BaseConstraintError<T> {\n\tpublic readonly expected: readonly string[];\n\n\tpublic constructor(constraint: ConstraintErrorNames, message: string, given: T, expected: readonly string[]) {\n\t\tsuper(constraint, message, given);\n\t\tthis.expected = expected;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tconstraint: this.constraint,\n\t\t\tgiven: this.given,\n\t\t\texpected: this.expected\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst constraint = options.stylize(this.constraint, 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[MultiplePossibilitiesConstraintError: ${constraint}]`, 'special');\n\t\t}\n\n\t\tconst newOptions = { ...options, depth: options.depth === null ? null : options.depth! - 1 };\n\n\t\tconst verticalLine = options.stylize('|', 'undefined');\n\t\tconst padding = `\\n ${verticalLine} `;\n\t\tconst given = inspect(this.given, newOptions).replace(/\\n/g, padding);\n\n\t\tconst header = `${options.stylize('MultiplePossibilitiesConstraintError', 'special')} > ${constraint}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\n\t\tconst expectedPadding = `\\n ${verticalLine} - `;\n\t\tconst expectedBlock = `\\n ${options.stylize('Expected any of the following:', 'string')}${expectedPadding}${this.expected\n\t\t\t.map((possible) => options.stylize(possible, 'boolean'))\n\t\t\t.join(expectedPadding)}`;\n\t\tconst givenBlock = `\\n ${options.stylize('Received:', 'regexp')}${padding}${given}`;\n\t\treturn `${header}\\n ${message}\\n${expectedBlock}\\n${givenBlock}`;\n\t}\n}\n","export function combinedErrorFn<P extends [...any], E extends Error>(...fns: ErrorFn<P, E>[]): ErrorFn<P, E> {\n\tswitch (fns.length) {\n\t\tcase 0:\n\t\t\treturn () => null;\n\t\tcase 1:\n\t\t\treturn fns[0];\n\t\tcase 2: {\n\t\t\tconst [fn0, fn1] = fns;\n\t\t\treturn (...params) => fn0(...params) || fn1(...params);\n\t\t}\n\t\tdefault: {\n\t\t\treturn (...params) => {\n\t\t\t\tfor (const fn of fns) {\n\t\t\t\t\tconst result = fn(...params);\n\t\t\t\t\tif (result) return result;\n\t\t\t\t}\n\n\t\t\t\treturn null;\n\t\t\t};\n\t\t}\n\t}\n}\n\nexport type ErrorFn<P extends [...any], E extends Error> = (...params: P) => E | null;\n","import { MultiplePossibilitiesConstraintError } from '../../lib/errors/MultiplePossibilitiesConstraintError';\nimport { combinedErrorFn, type ErrorFn } from './common/combinedResultFn';\n\nexport type StringProtocol = `${string}:`;\n\nexport type StringDomain = `${string}.${string}`;\n\nexport interface UrlOptions {\n\tallowedProtocols?: StringProtocol[];\n\tallowedDomains?: StringDomain[];\n}\n\nexport function createUrlValidators(options?: UrlOptions) {\n\tconst fns: ErrorFn<[input: string, url: URL], MultiplePossibilitiesConstraintError<string>>[] = [];\n\n\tif (options?.allowedProtocols?.length) fns.push(allowedProtocolsFn(options.allowedProtocols));\n\tif (options?.allowedDomains?.length) fns.push(allowedDomainsFn(options.allowedDomains));\n\n\treturn combinedErrorFn(...fns);\n}\n\nfunction allowedProtocolsFn(allowedProtocols: StringProtocol[]) {\n\treturn (input: string, url: URL) =>\n\t\tallowedProtocols.includes(url.protocol as StringProtocol)\n\t\t\t? null\n\t\t\t: new MultiplePossibilitiesConstraintError('s.string.url', 'Invalid URL protocol', input, allowedProtocols);\n}\n\nfunction allowedDomainsFn(allowedDomains: StringDomain[]) {\n\treturn (input: string, url: URL) =>\n\t\tallowedDomains.includes(url.hostname as StringDomain)\n\t\t\t? null\n\t\t\t: new MultiplePossibilitiesConstraintError('s.string.url', 'Invalid URL domain', input, allowedDomains);\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { validateEmail } from './util/emailValidator';\nimport { isIP, isIPv4, isIPv6 } from './util/net';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\nimport { validatePhoneNumber } from './util/phoneValidator';\nimport { createUrlValidators } from './util/urlValidators';\n\nexport type StringConstraintName =\n\t| `s.string.${\n\t\t\t| `length${'LessThan' | 'LessThanOrEqual' | 'GreaterThan' | 'GreaterThanOrEqual' | 'Equal' | 'NotEqual'}`\n\t\t\t| 'regex'\n\t\t\t| 'url'\n\t\t\t| 'uuid'\n\t\t\t| 'email'\n\t\t\t| `ip${'v4' | 'v6' | ''}`\n\t\t\t| 'date'\n\t\t\t| 'phone'}`;\n\nexport type StringProtocol = `${string}:`;\n\nexport type StringDomain = `${string}.${string}`;\n\nexport interface UrlOptions {\n\tallowedProtocols?: StringProtocol[];\n\tallowedDomains?: StringDomain[];\n}\n\nexport type UUIDVersion = 1 | 3 | 4 | 5;\n\nexport interface StringUuidOptions {\n\tversion?: UUIDVersion | `${UUIDVersion}-${UUIDVersion}` | null;\n\tnullable?: boolean;\n}\n\nfunction stringLengthComparator(comparator: Comparator, name: StringConstraintName, expected: string, length: number): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn comparator(input.length, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid string length', input, expected));\n\t\t}\n\t};\n}\n\nexport function stringLengthLessThan(length: number): IConstraint<string> {\n\tconst expected = `expected.length < ${length}`;\n\treturn stringLengthComparator(lessThan, 's.string.lengthLessThan', expected, length);\n}\n\nexport function stringLengthLessThanOrEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length <= ${length}`;\n\treturn stringLengthComparator(lessThanOrEqual, 's.string.lengthLessThanOrEqual', expected, length);\n}\n\nexport function stringLengthGreaterThan(length: number): IConstraint<string> {\n\tconst expected = `expected.length > ${length}`;\n\treturn stringLengthComparator(greaterThan, 's.string.lengthGreaterThan', expected, length);\n}\n\nexport function stringLengthGreaterThanOrEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length >= ${length}`;\n\treturn stringLengthComparator(greaterThanOrEqual, 's.string.lengthGreaterThanOrEqual', expected, length);\n}\n\nexport function stringLengthEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length === ${length}`;\n\treturn stringLengthComparator(equal, 's.string.lengthEqual', expected, length);\n}\n\nexport function stringLengthNotEqual(length: number): IConstraint<string> {\n\tconst expected = `expected.length !== ${length}`;\n\treturn stringLengthComparator(notEqual, 's.string.lengthNotEqual', expected, length);\n}\n\nexport function stringEmail(): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn validateEmail(input)\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.string.email', 'Invalid email address', input, 'expected to be an email address'));\n\t\t}\n\t};\n}\n\nfunction stringRegexValidator(type: StringConstraintName, expected: string, regex: RegExp): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn regex.test(input) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(type, 'Invalid string format', input, expected));\n\t\t}\n\t};\n}\n\nexport function stringUrl(options?: UrlOptions): IConstraint<string> {\n\tconst validatorFn = createUrlValidators(options);\n\treturn {\n\t\trun(input: string) {\n\t\t\tlet url: URL;\n\t\t\ttry {\n\t\t\t\turl = new URL(input);\n\t\t\t} catch {\n\t\t\t\treturn Result.err(new ExpectedConstraintError('s.string.url', 'Invalid URL', input, 'expected to match a URL'));\n\t\t\t}\n\n\t\t\tconst validatorFnResult = validatorFn(input, url);\n\t\t\tif (validatorFnResult === null) return Result.ok(input);\n\t\t\treturn Result.err(validatorFnResult);\n\t\t}\n\t};\n}\n\nexport function stringIp(version?: 4 | 6): IConstraint<string> {\n\tconst ipVersion = version ? (`v${version}` as const) : '';\n\tconst validatorFn = version === 4 ? isIPv4 : version === 6 ? isIPv6 : isIP;\n\n\tconst name = `s.string.ip${ipVersion}` as const;\n\tconst message = `Invalid IP${ipVersion} address`;\n\tconst expected = `expected to be an IP${ipVersion} address`;\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn validatorFn(input) ? Result.ok(input) : Result.err(new ExpectedConstraintError(name, message, input, expected));\n\t\t}\n\t};\n}\n\nexport function stringRegex(regex: RegExp) {\n\treturn stringRegexValidator('s.string.regex', `expected ${regex}.test(expected) to be true`, regex);\n}\n\nexport function stringUuid({ version = 4, nullable = false }: StringUuidOptions = {}) {\n\tversion ??= '1-5';\n\tconst regex = new RegExp(\n\t\t`^(?:[0-9A-F]{8}-[0-9A-F]{4}-[${version}][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}${\n\t\t\tnullable ? '|00000000-0000-0000-0000-000000000000' : ''\n\t\t})$`,\n\t\t'i'\n\t);\n\tconst expected = `expected to match UUID${typeof version === 'number' ? `v${version}` : ` in range of ${version}`}`;\n\treturn stringRegexValidator('s.string.uuid', expected, regex);\n}\n\nexport function stringDate(): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\tconst time = Date.parse(input);\n\n\t\t\treturn Number.isNaN(time)\n\t\t\t\t? Result.err(\n\t\t\t\t\t\tnew ExpectedConstraintError(\n\t\t\t\t\t\t\t's.string.date',\n\t\t\t\t\t\t\t'Invalid date string',\n\t\t\t\t\t\t\tinput,\n\t\t\t\t\t\t\t'expected to be a valid date string (in the ISO 8601 or ECMA-262 format)'\n\t\t\t\t\t\t)\n\t\t\t\t )\n\t\t\t\t: Result.ok(input);\n\t\t}\n\t};\n}\n\nexport function stringPhone(): IConstraint<string> {\n\treturn {\n\t\trun(input: string) {\n\t\t\treturn validatePhoneNumber(input)\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.string.phone', 'Invalid phone number', input, 'expected to be a phone number'));\n\t\t}\n\t};\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\tstringDate,\n\tstringEmail,\n\tstringIp,\n\tstringLengthEqual,\n\tstringLengthGreaterThan,\n\tstringLengthGreaterThanOrEqual,\n\tstringLengthLessThan,\n\tstringLengthLessThanOrEqual,\n\tstringLengthNotEqual,\n\tstringPhone,\n\tstringRegex,\n\tstringUrl,\n\tstringUuid,\n\ttype StringUuidOptions,\n\ttype UrlOptions\n} from '../constraints/StringConstraints';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class StringValidator<T extends string> extends BaseValidator<T> {\n\tpublic lengthLessThan(length: number): this {\n\t\treturn this.addConstraint(stringLengthLessThan(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthLessThanOrEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthLessThanOrEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthGreaterThan(length: number): this {\n\t\treturn this.addConstraint(stringLengthGreaterThan(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthGreaterThanOrEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthGreaterThanOrEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic lengthNotEqual(length: number): this {\n\t\treturn this.addConstraint(stringLengthNotEqual(length) as IConstraint<T>);\n\t}\n\n\tpublic get email(): this {\n\t\treturn this.addConstraint(stringEmail() as IConstraint<T>);\n\t}\n\n\tpublic url(options?: UrlOptions): this {\n\t\treturn this.addConstraint(stringUrl(options) as IConstraint<T>);\n\t}\n\n\tpublic uuid(options?: StringUuidOptions): this {\n\t\treturn this.addConstraint(stringUuid(options) as IConstraint<T>);\n\t}\n\n\tpublic regex(regex: RegExp): this {\n\t\treturn this.addConstraint(stringRegex(regex) as IConstraint<T>);\n\t}\n\n\tpublic get date() {\n\t\treturn this.addConstraint(stringDate() as IConstraint<T>);\n\t}\n\n\tpublic get ipv4(): this {\n\t\treturn this.ip(4);\n\t}\n\n\tpublic get ipv6(): this {\n\t\treturn this.ip(6);\n\t}\n\n\tpublic ip(version?: 4 | 6): this {\n\t\treturn this.addConstraint(stringIp(version) as IConstraint<T>);\n\t}\n\n\tpublic phone(): this {\n\t\treturn this.addConstraint(stringPhone() as IConstraint<T>);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn typeof value === 'string' //\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.string', 'Expected a string primitive', value));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class TupleValidator<T extends any[]> extends BaseValidator<[...T]> {\n\tprivate readonly validators: BaseValidator<[...T]>[] = [];\n\n\tpublic constructor(validators: BaseValidator<[...T]>[], constraints: readonly IConstraint<[...T]>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validators = validators;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validators, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<[...T], ValidationError | CombinedPropertyError> {\n\t\tif (!Array.isArray(values)) {\n\t\t\treturn Result.err(new ValidationError('s.tuple(T)', 'Expected an array', values));\n\t\t}\n\n\t\tif (values.length !== this.validators.length) {\n\t\t\treturn Result.err(new ValidationError('s.tuple(T)', `Expected an array of length ${this.validators.length}`, values));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(values as [...T]);\n\t\t}\n\n\t\tconst errors: [number, BaseError][] = [];\n\t\tconst transformed: T = [] as unknown as T;\n\n\t\tfor (let i = 0; i < values.length; i++) {\n\t\t\tconst result = this.validators[i].run(values[i]);\n\t\t\tif (result.isOk()) transformed.push(result.value);\n\t\t\telse errors.push([i, result.error!]);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport type { BaseError } from '../lib/errors/BaseError';\nimport { CombinedPropertyError } from '../lib/errors/CombinedPropertyError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class MapValidator<K, V> extends BaseValidator<Map<K, V>> {\n\tprivate readonly keyValidator: BaseValidator<K>;\n\tprivate readonly valueValidator: BaseValidator<V>;\n\n\tpublic constructor(keyValidator: BaseValidator<K>, valueValidator: BaseValidator<V>, constraints: readonly IConstraint<Map<K, V>>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.keyValidator = keyValidator;\n\t\tthis.valueValidator = valueValidator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.keyValidator, this.valueValidator, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<Map<K, V>, ValidationError | CombinedPropertyError> {\n\t\tif (!(value instanceof Map)) {\n\t\t\treturn Result.err(new ValidationError('s.map(K, V)', 'Expected a map', value));\n\t\t}\n\n\t\tif (!this.shouldRunConstraints) {\n\t\t\treturn Result.ok(value);\n\t\t}\n\n\t\tconst errors: [string, BaseError][] = [];\n\t\tconst transformed = new Map<K, V>();\n\n\t\tfor (const [key, val] of value.entries()) {\n\t\t\tconst keyResult = this.keyValidator.run(key);\n\t\t\tconst valueResult = this.valueValidator.run(val);\n\t\t\tconst { length } = errors;\n\t\t\tif (keyResult.isErr()) errors.push([key, keyResult.error]);\n\t\t\tif (valueResult.isErr()) errors.push([key, valueResult.error]);\n\t\t\tif (errors.length === length) transformed.set(keyResult.value!, valueResult.value!);\n\t\t}\n\n\t\treturn errors.length === 0 //\n\t\t\t? Result.ok(transformed)\n\t\t\t: Result.err(new CombinedPropertyError(errors));\n\t}\n}\n","import type { Result } from '../lib/Result';\nimport type { IConstraint, Unwrap } from '../type-exports';\nimport { BaseValidator, type ValidatorError } from './imports';\n\nexport class LazyValidator<T extends BaseValidator<unknown>, R = Unwrap<T>> extends BaseValidator<R> {\n\tprivate readonly validator: (value: unknown) => T;\n\n\tpublic constructor(validator: (value: unknown) => T, constraints: readonly IConstraint<R>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.validator = validator;\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.validator, this.constraints]);\n\t}\n\n\tprotected handle(values: unknown): Result<R, ValidatorError> {\n\t\treturn this.validator(values).run(values) as Result<R, ValidatorError>;\n\t}\n}\n","import type { InspectOptionsStylized } from 'util';\nimport { BaseError, customInspectSymbolStackLess } from './BaseError';\n\nexport class UnknownEnumValueError extends BaseError {\n\tpublic readonly value: string | number;\n\tpublic readonly enumKeys: string[];\n\tpublic readonly enumMappings: Map<string | number, string | number>;\n\n\tpublic constructor(value: string | number, keys: string[], enumMappings: Map<string | number, string | number>) {\n\t\tsuper('Expected the value to be one of the following enum values:');\n\n\t\tthis.value = value;\n\t\tthis.enumKeys = keys;\n\t\tthis.enumMappings = enumMappings;\n\t}\n\n\tpublic toJSON() {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tvalue: this.value,\n\t\t\tenumKeys: this.enumKeys,\n\t\t\tenumMappings: [...this.enumMappings.entries()]\n\t\t};\n\t}\n\n\tprotected [customInspectSymbolStackLess](depth: number, options: InspectOptionsStylized): string {\n\t\tconst value = options.stylize(this.value.toString(), 'string');\n\t\tif (depth < 0) {\n\t\t\treturn options.stylize(`[UnknownEnumValueError: ${value}]`, 'special');\n\t\t}\n\n\t\tconst padding = `\\n ${options.stylize('|', 'undefined')} `;\n\t\tconst pairs = this.enumKeys\n\t\t\t.map((key) => {\n\t\t\t\tconst enumValue = this.enumMappings.get(key)!;\n\t\t\t\treturn `${options.stylize(key, 'string')} or ${options.stylize(\n\t\t\t\t\tenumValue.toString(),\n\t\t\t\t\ttypeof enumValue === 'number' ? 'number' : 'string'\n\t\t\t\t)}`;\n\t\t\t})\n\t\t\t.join(padding);\n\n\t\tconst header = `${options.stylize('UnknownEnumValueError', 'special')} > ${value}`;\n\t\tconst message = options.stylize(this.message, 'regexp');\n\t\tconst pairsBlock = `${padding}${pairs}`;\n\t\treturn `${header}\\n ${message}\\n${pairsBlock}`;\n\t}\n}\n","import { UnknownEnumValueError } from '../lib/errors/UnknownEnumValueError';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class NativeEnumValidator<T extends NativeEnumLike> extends BaseValidator<T[keyof T]> {\n\tpublic readonly enumShape: T;\n\tpublic readonly hasNumericElements: boolean = false;\n\tprivate readonly enumKeys: string[];\n\tprivate readonly enumMapping = new Map<string | number, T[keyof T]>();\n\n\tpublic constructor(enumShape: T) {\n\t\tsuper();\n\t\tthis.enumShape = enumShape;\n\n\t\tthis.enumKeys = Object.keys(enumShape).filter((key) => {\n\t\t\treturn typeof enumShape[enumShape[key]] !== 'number';\n\t\t});\n\n\t\tfor (const key of this.enumKeys) {\n\t\t\tconst enumValue = enumShape[key] as T[keyof T];\n\n\t\t\tthis.enumMapping.set(key, enumValue);\n\t\t\tthis.enumMapping.set(enumValue, enumValue);\n\n\t\t\tif (typeof enumValue === 'number') {\n\t\t\t\tthis.hasNumericElements = true;\n\t\t\t\tthis.enumMapping.set(`${enumValue}`, enumValue);\n\t\t\t}\n\t\t}\n\t}\n\n\tprotected override handle(value: unknown): Result<T[keyof T], ValidationError | UnknownEnumValueError> {\n\t\tconst typeOfValue = typeof value;\n\n\t\tif (typeOfValue === 'number') {\n\t\t\tif (!this.hasNumericElements) {\n\t\t\t\treturn Result.err(new ValidationError('s.nativeEnum(T)', 'Expected the value to be a string', value));\n\t\t\t}\n\t\t} else if (typeOfValue !== 'string') {\n\t\t\t// typeOfValue !== 'number' is implied here\n\t\t\treturn Result.err(new ValidationError('s.nativeEnum(T)', 'Expected the value to be a string or number', value));\n\t\t}\n\n\t\tconst casted = value as string | number;\n\n\t\tconst possibleEnumValue = this.enumMapping.get(casted);\n\n\t\treturn typeof possibleEnumValue === 'undefined'\n\t\t\t? Result.err(new UnknownEnumValueError(casted, this.enumKeys, this.enumMapping))\n\t\t\t: Result.ok(possibleEnumValue);\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.enumShape]);\n\t}\n}\n\nexport interface NativeEnumLike {\n\t[key: string]: string | number;\n\t[key: number]: string;\n}\n","import { ExpectedConstraintError } from '../lib/errors/ExpectedConstraintError';\nimport { Result } from '../lib/Result';\nimport type { IConstraint } from './base/IConstraint';\nimport { equal, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, notEqual, type Comparator } from './util/operators';\nimport type { TypedArray } from './util/typedArray';\n\nexport type TypedArrayConstraintName = `s.typedArray(T).${'byteLength' | 'length'}${\n\t| 'LessThan'\n\t| 'LessThanOrEqual'\n\t| 'GreaterThan'\n\t| 'GreaterThanOrEqual'\n\t| 'Equal'\n\t| 'NotEqual'\n\t| 'Range'\n\t| 'RangeInclusive'\n\t| 'RangeExclusive'}`;\n\nfunction typedArrayByteLengthComparator<T extends TypedArray>(\n\tcomparator: Comparator,\n\tname: TypedArrayConstraintName,\n\texpected: string,\n\tlength: number\n): IConstraint<T> {\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn comparator(input.byteLength, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Typed Array byte length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayByteLengthLessThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength < ${value}`;\n\treturn typedArrayByteLengthComparator(lessThan, 's.typedArray(T).byteLengthLessThan', expected, value);\n}\n\nexport function typedArrayByteLengthLessThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength <= ${value}`;\n\treturn typedArrayByteLengthComparator(lessThanOrEqual, 's.typedArray(T).byteLengthLessThanOrEqual', expected, value);\n}\n\nexport function typedArrayByteLengthGreaterThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength > ${value}`;\n\treturn typedArrayByteLengthComparator(greaterThan, 's.typedArray(T).byteLengthGreaterThan', expected, value);\n}\n\nexport function typedArrayByteLengthGreaterThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength >= ${value}`;\n\treturn typedArrayByteLengthComparator(greaterThanOrEqual, 's.typedArray(T).byteLengthGreaterThanOrEqual', expected, value);\n}\n\nexport function typedArrayByteLengthEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength === ${value}`;\n\treturn typedArrayByteLengthComparator(equal, 's.typedArray(T).byteLengthEqual', expected, value);\n}\n\nexport function typedArrayByteLengthNotEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.byteLength !== ${value}`;\n\treturn typedArrayByteLengthComparator(notEqual, 's.typedArray(T).byteLengthNotEqual', expected, value);\n}\n\nexport function typedArrayByteLengthRange<T extends TypedArray>(start: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.byteLength >= ${start} && expected.byteLength < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.byteLength >= start && input.byteLength < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).byteLengthRange', 'Invalid Typed Array byte length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayByteLengthRangeInclusive<T extends TypedArray>(start: number, end: number) {\n\tconst expected = `expected.byteLength >= ${start} && expected.byteLength <= ${end}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.byteLength >= start && input.byteLength <= end //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(\n\t\t\t\t\t\tnew ExpectedConstraintError('s.typedArray(T).byteLengthRangeInclusive', 'Invalid Typed Array byte length', input, expected)\n\t\t\t\t );\n\t\t}\n\t};\n}\n\nexport function typedArrayByteLengthRangeExclusive<T extends TypedArray>(startAfter: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.byteLength > ${startAfter} && expected.byteLength < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.byteLength > startAfter && input.byteLength < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(\n\t\t\t\t\t\tnew ExpectedConstraintError('s.typedArray(T).byteLengthRangeExclusive', 'Invalid Typed Array byte length', input, expected)\n\t\t\t\t );\n\t\t}\n\t};\n}\n\nfunction typedArrayLengthComparator<T extends TypedArray>(\n\tcomparator: Comparator,\n\tname: TypedArrayConstraintName,\n\texpected: string,\n\tlength: number\n): IConstraint<T> {\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn comparator(input.length, length) //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError(name, 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayLengthLessThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length < ${value}`;\n\treturn typedArrayLengthComparator(lessThan, 's.typedArray(T).lengthLessThan', expected, value);\n}\n\nexport function typedArrayLengthLessThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length <= ${value}`;\n\treturn typedArrayLengthComparator(lessThanOrEqual, 's.typedArray(T).lengthLessThanOrEqual', expected, value);\n}\n\nexport function typedArrayLengthGreaterThan<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length > ${value}`;\n\treturn typedArrayLengthComparator(greaterThan, 's.typedArray(T).lengthGreaterThan', expected, value);\n}\n\nexport function typedArrayLengthGreaterThanOrEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length >= ${value}`;\n\treturn typedArrayLengthComparator(greaterThanOrEqual, 's.typedArray(T).lengthGreaterThanOrEqual', expected, value);\n}\n\nexport function typedArrayLengthEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length === ${value}`;\n\treturn typedArrayLengthComparator(equal, 's.typedArray(T).lengthEqual', expected, value);\n}\n\nexport function typedArrayLengthNotEqual<T extends TypedArray>(value: number): IConstraint<T> {\n\tconst expected = `expected.length !== ${value}`;\n\treturn typedArrayLengthComparator(notEqual, 's.typedArray(T).lengthNotEqual', expected, value);\n}\n\nexport function typedArrayLengthRange<T extends TypedArray>(start: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.length >= ${start} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.length >= start && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).lengthRange', 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayLengthRangeInclusive<T extends TypedArray>(start: number, end: number): IConstraint<T> {\n\tconst expected = `expected.length >= ${start} && expected.length <= ${end}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.length >= start && input.length <= end //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).lengthRangeInclusive', 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n\nexport function typedArrayLengthRangeExclusive<T extends TypedArray>(startAfter: number, endBefore: number): IConstraint<T> {\n\tconst expected = `expected.length > ${startAfter} && expected.length < ${endBefore}`;\n\treturn {\n\t\trun(input: T) {\n\t\t\treturn input.length > startAfter && input.length < endBefore //\n\t\t\t\t? Result.ok(input)\n\t\t\t\t: Result.err(new ExpectedConstraintError('s.typedArray(T).lengthRangeExclusive', 'Invalid Typed Array length', input, expected));\n\t\t}\n\t};\n}\n","const vowels = ['a', 'e', 'i', 'o', 'u'];\n\nexport const aOrAn = (word: string) => {\n\treturn `${vowels.includes(word[0].toLowerCase()) ? 'an' : 'a'} ${word}`;\n};\n","export type TypedArray =\n\t| Int8Array\n\t| Uint8Array\n\t| Uint8ClampedArray\n\t| Int16Array\n\t| Uint16Array\n\t| Int32Array\n\t| Uint32Array\n\t| Float32Array\n\t| Float64Array\n\t| BigInt64Array\n\t| BigUint64Array;\n\nexport const TypedArrays = {\n\tInt8Array: (x: unknown): x is Int8Array => x instanceof Int8Array,\n\tUint8Array: (x: unknown): x is Uint8Array => x instanceof Uint8Array,\n\tUint8ClampedArray: (x: unknown): x is Uint8ClampedArray => x instanceof Uint8ClampedArray,\n\tInt16Array: (x: unknown): x is Int16Array => x instanceof Int16Array,\n\tUint16Array: (x: unknown): x is Uint16Array => x instanceof Uint16Array,\n\tInt32Array: (x: unknown): x is Int32Array => x instanceof Int32Array,\n\tUint32Array: (x: unknown): x is Uint32Array => x instanceof Uint32Array,\n\tFloat32Array: (x: unknown): x is Float32Array => x instanceof Float32Array,\n\tFloat64Array: (x: unknown): x is Float64Array => x instanceof Float64Array,\n\tBigInt64Array: (x: unknown): x is BigInt64Array => x instanceof BigInt64Array,\n\tBigUint64Array: (x: unknown): x is BigUint64Array => x instanceof BigUint64Array,\n\tTypedArray: (x: unknown): x is TypedArray => ArrayBuffer.isView(x) && !(x instanceof DataView)\n} as const;\n\nexport type TypedArrayName = keyof typeof TypedArrays;\n","import type { IConstraint } from '../constraints/base/IConstraint';\nimport {\n\ttypedArrayByteLengthEqual,\n\ttypedArrayByteLengthGreaterThan,\n\ttypedArrayByteLengthGreaterThanOrEqual,\n\ttypedArrayByteLengthLessThan,\n\ttypedArrayByteLengthLessThanOrEqual,\n\ttypedArrayByteLengthNotEqual,\n\ttypedArrayByteLengthRange,\n\ttypedArrayByteLengthRangeExclusive,\n\ttypedArrayByteLengthRangeInclusive,\n\ttypedArrayLengthEqual,\n\ttypedArrayLengthGreaterThan,\n\ttypedArrayLengthGreaterThanOrEqual,\n\ttypedArrayLengthLessThan,\n\ttypedArrayLengthLessThanOrEqual,\n\ttypedArrayLengthNotEqual,\n\ttypedArrayLengthRange,\n\ttypedArrayLengthRangeExclusive,\n\ttypedArrayLengthRangeInclusive\n} from '../constraints/TypedArrayLengthConstraints';\nimport { aOrAn } from '../constraints/util/common/vowels';\nimport { TypedArrays, type TypedArray, type TypedArrayName } from '../constraints/util/typedArray';\nimport { ValidationError } from '../lib/errors/ValidationError';\nimport { Result } from '../lib/Result';\nimport { BaseValidator } from './imports';\n\nexport class TypedArrayValidator<T extends TypedArray> extends BaseValidator<T> {\n\tprivate readonly type: TypedArrayName;\n\n\tpublic constructor(type: TypedArrayName, constraints: readonly IConstraint<T>[] = []) {\n\t\tsuper(constraints);\n\t\tthis.type = type;\n\t}\n\n\tpublic byteLengthLessThan(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthLessThan(length));\n\t}\n\n\tpublic byteLengthLessThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthLessThanOrEqual(length));\n\t}\n\n\tpublic byteLengthGreaterThan(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthGreaterThan(length));\n\t}\n\n\tpublic byteLengthGreaterThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthGreaterThanOrEqual(length));\n\t}\n\n\tpublic byteLengthEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthEqual(length));\n\t}\n\n\tpublic byteLengthNotEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthNotEqual(length));\n\t}\n\n\tpublic byteLengthRange(start: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthRange(start, endBefore));\n\t}\n\n\tpublic byteLengthRangeInclusive(startAt: number, endAt: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthRangeInclusive(startAt, endAt) as IConstraint<T>);\n\t}\n\n\tpublic byteLengthRangeExclusive(startAfter: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayByteLengthRangeExclusive(startAfter, endBefore));\n\t}\n\n\tpublic lengthLessThan(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthLessThan(length));\n\t}\n\n\tpublic lengthLessThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthLessThanOrEqual(length));\n\t}\n\n\tpublic lengthGreaterThan(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthGreaterThan(length));\n\t}\n\n\tpublic lengthGreaterThanOrEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthGreaterThanOrEqual(length));\n\t}\n\n\tpublic lengthEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthEqual(length));\n\t}\n\n\tpublic lengthNotEqual(length: number) {\n\t\treturn this.addConstraint(typedArrayLengthNotEqual(length));\n\t}\n\n\tpublic lengthRange(start: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayLengthRange(start, endBefore));\n\t}\n\n\tpublic lengthRangeInclusive(startAt: number, endAt: number) {\n\t\treturn this.addConstraint(typedArrayLengthRangeInclusive(startAt, endAt));\n\t}\n\n\tpublic lengthRangeExclusive(startAfter: number, endBefore: number) {\n\t\treturn this.addConstraint(typedArrayLengthRangeExclusive(startAfter, endBefore));\n\t}\n\n\tprotected override clone(): this {\n\t\treturn Reflect.construct(this.constructor, [this.type, this.constraints]);\n\t}\n\n\tprotected handle(value: unknown): Result<T, ValidationError> {\n\t\treturn TypedArrays[this.type](value)\n\t\t\t? Result.ok(value as T)\n\t\t\t: Result.err(new ValidationError('s.typedArray', `Expected ${aOrAn(this.type)}`, value));\n\t}\n}\n","import type { TypedArray, TypedArrayName } from '../constraints/util/typedArray';\nimport type { Unwrap, UnwrapTuple } from '../lib/util-types';\nimport {\n\tArrayValidator,\n\tBaseValidator,\n\tBigIntValidator,\n\tBooleanValidator,\n\tDateValidator,\n\tInstanceValidator,\n\tLiteralValidator,\n\tMapValidator,\n\tNeverValidator,\n\tNullishValidator,\n\tNumberValidator,\n\tObjectValidator,\n\tPassthroughValidator,\n\tRecordValidator,\n\tSetValidator,\n\tStringValidator,\n\tTupleValidator,\n\tUnionValidator\n} from '../validators/imports';\nimport { LazyValidator } from '../validators/LazyValidator';\nimport { NativeEnumValidator, type NativeEnumLike } from '../validators/NativeEnumValidator';\nimport { TypedArrayValidator } from '../validators/TypedArrayValidator';\nimport type { Constructor, MappedObjectValidator } from './util-types';\n\nexport class Shapes {\n\tpublic get string() {\n\t\treturn new StringValidator();\n\t}\n\n\tpublic get number() {\n\t\treturn new NumberValidator();\n\t}\n\n\tpublic get bigint() {\n\t\treturn new BigIntValidator();\n\t}\n\n\tpublic get boolean() {\n\t\treturn new BooleanValidator();\n\t}\n\n\tpublic get date() {\n\t\treturn new DateValidator();\n\t}\n\n\tpublic object<T extends object>(shape: MappedObjectValidator<T>) {\n\t\treturn new ObjectValidator<T>(shape);\n\t}\n\n\tpublic get undefined() {\n\t\treturn this.literal(undefined);\n\t}\n\n\tpublic get null() {\n\t\treturn this.literal(null);\n\t}\n\n\tpublic get nullish() {\n\t\treturn new NullishValidator();\n\t}\n\n\tpublic get any() {\n\t\treturn new PassthroughValidator<any>();\n\t}\n\n\tpublic get unknown() {\n\t\treturn new PassthroughValidator<unknown>();\n\t}\n\n\tpublic get never() {\n\t\treturn new NeverValidator();\n\t}\n\n\tpublic enum<T>(...values: readonly T[]) {\n\t\treturn this.union(...values.map((value) => this.literal(value)));\n\t}\n\n\tpublic nativeEnum<T extends NativeEnumLike>(enumShape: T): NativeEnumValidator<T> {\n\t\treturn new NativeEnumValidator(enumShape);\n\t}\n\n\tpublic literal<T>(value: T): BaseValidator<T> {\n\t\tif (value instanceof Date) return this.date.equal(value) as unknown as BaseValidator<T>;\n\t\treturn new LiteralValidator(value);\n\t}\n\n\tpublic instance<T>(expected: Constructor<T>): InstanceValidator<T> {\n\t\treturn new InstanceValidator(expected);\n\t}\n\n\tpublic union<T extends [...BaseValidator<any>[]]>(...validators: [...T]): UnionValidator<Unwrap<T[number]>> {\n\t\treturn new UnionValidator(validators);\n\t}\n\n\tpublic array<T>(validator: BaseValidator<T[][number]>): ArrayValidator<T[], T[][number]>;\n\tpublic array<T extends unknown[]>(validator: BaseValidator<T[number]>): ArrayValidator<T, T[number]>;\n\tpublic array<T extends unknown[]>(validator: BaseValidator<T[number]>) {\n\t\treturn new ArrayValidator(validator);\n\t}\n\n\tpublic typedArray<T extends TypedArray>(type: TypedArrayName = 'TypedArray') {\n\t\treturn new TypedArrayValidator<T>(type);\n\t}\n\n\tpublic get int8Array() {\n\t\treturn this.typedArray<Int8Array>('Int8Array');\n\t}\n\n\tpublic get uint8Array() {\n\t\treturn this.typedArray<Uint8Array>('Uint8Array');\n\t}\n\n\tpublic get uint8ClampedArray() {\n\t\treturn this.typedArray<Uint8ClampedArray>('Uint8ClampedArray');\n\t}\n\n\tpublic get int16Array() {\n\t\treturn this.typedArray<Int16Array>('Int16Array');\n\t}\n\n\tpublic get uint16Array() {\n\t\treturn this.typedArray<Uint16Array>('Uint16Array');\n\t}\n\n\tpublic get int32Array() {\n\t\treturn this.typedArray<Int32Array>('Int32Array');\n\t}\n\n\tpublic get uint32Array() {\n\t\treturn this.typedArray<Uint32Array>('Uint32Array');\n\t}\n\n\tpublic get float32Array() {\n\t\treturn this.typedArray<Float32Array>('Float32Array');\n\t}\n\n\tpublic get float64Array() {\n\t\treturn this.typedArray<Float64Array>('Float64Array');\n\t}\n\n\tpublic get bigInt64Array() {\n\t\treturn this.typedArray<BigInt64Array>('BigInt64Array');\n\t}\n\n\tpublic get bigUint64Array() {\n\t\treturn this.typedArray<BigUint64Array>('BigUint64Array');\n\t}\n\n\tpublic tuple<T extends [...BaseValidator<any>[]]>(validators: [...T]): TupleValidator<UnwrapTuple<T>> {\n\t\treturn new TupleValidator(validators);\n\t}\n\n\tpublic set<T>(validator: BaseValidator<T>) {\n\t\treturn new SetValidator(validator);\n\t}\n\n\tpublic record<T>(validator: BaseValidator<T>) {\n\t\treturn new RecordValidator(validator);\n\t}\n\n\tpublic map<T, U>(keyValidator: BaseValidator<T>, valueValidator: BaseValidator<U>) {\n\t\treturn new MapValidator(keyValidator, valueValidator);\n\t}\n\n\tpublic lazy<T extends BaseValidator<unknown>>(validator: (value: unknown) => T) {\n\t\treturn new LazyValidator(validator);\n\t}\n}\n","import { Shapes } from './lib/Shapes';\n\nexport const s = new Shapes();\n\nexport * from './lib/Result';\nexport * from './lib/configs';\nexport * from './lib/errors/BaseError';\nexport * from './lib/errors/CombinedError';\nexport * from './lib/errors/CombinedPropertyError';\nexport * from './lib/errors/ExpectedConstraintError';\nexport * from './lib/errors/ExpectedValidationError';\nexport * from './lib/errors/MissingPropertyError';\nexport * from './lib/errors/MultiplePossibilitiesConstraintError';\nexport * from './lib/errors/UnknownEnumValueError';\nexport * from './lib/errors/UnknownPropertyError';\nexport * from './lib/errors/ValidationError';\nexport * from './type-exports';\n"]}
\ No newline at end of file diff --git a/node_modules/@sapphire/shapeshift/package.json b/node_modules/@sapphire/shapeshift/package.json new file mode 100644 index 0000000..cd7d6e6 --- /dev/null +++ b/node_modules/@sapphire/shapeshift/package.json @@ -0,0 +1,125 @@ +{ + "name": "@sapphire/shapeshift", + "version": "3.9.2", + "description": "Blazing fast input validation and transformation β‘", + "author": "@sapphire", + "license": "MIT", + "main": "dist/index.js", + "module": "dist/index.mjs", + "browser": "dist/index.global.js", + "unpkg": "dist/index.global.js", + "types": "dist/index.d.ts", + "exports": { + "types": "./dist/index.d.ts", + "import": "./dist/index.mjs", + "require": "./dist/index.js" + }, + "sideEffects": false, + "homepage": "https://www.sapphirejs.dev", + "scripts": { + "lint": "eslint src tests --ext ts --fix", + "format": "prettier --write \"{src,tests}/**/*.ts\"", + "docs": "typedoc-json-parser", + "test": "vitest run", + "build": "tsup", + "clean": "node scripts/clean.mjs", + "typecheck": "tsc -p tsconfig.eslint.json", + "bump": "cliff-jumper", + "check-update": "cliff-jumper --dry-run", + "_postinstall": "husky install .github/husky", + "prepack": "yarn build && pinst --disable", + "postpack": "pinst --enable" + }, + "dependencies": { + "fast-deep-equal": "^3.1.3", + "lodash": "^4.17.21" + }, + "devDependencies": { + "@commitlint/cli": "^17.6.5", + "@commitlint/config-conventional": "^17.6.5", + "@favware/cliff-jumper": "^2.0.1", + "@favware/npm-deprecate": "^1.0.7", + "@sapphire/eslint-config": "^4.4.2", + "@sapphire/prettier-config": "^1.4.5", + "@sapphire/ts-config": "^4.0.0", + "@types/jsdom": "^21.1.1", + "@types/lodash": "^4.14.195", + "@types/node": "^18.16.16", + "@typescript-eslint/eslint-plugin": "^5.59.8", + "@typescript-eslint/parser": "^5.59.8", + "@vitest/coverage-c8": "^0.31.4", + "cz-conventional-changelog": "^3.3.0", + "esbuild-plugins-node-modules-polyfill": "^1.0.14", + "eslint": "^8.42.0", + "eslint-config-prettier": "^8.8.0", + "eslint-plugin-prettier": "^4.2.1", + "husky": "^8.0.3", + "jsdom": "^22.1.0", + "lint-staged": "^13.2.2", + "pinst": "^3.0.0", + "prettier": "^2.8.8", + "pretty-quick": "^3.1.3", + "ts-node": "^10.9.1", + "tsup": "^6.7.0", + "typedoc": "^0.24.7", + "typedoc-json-parser": "^8.1.2", + "typescript": "^5.1.3", + "vite": "^4.3.9", + "vitest": "^0.31.4" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/sapphiredev/shapeshift.git" + }, + "files": [ + "dist/**/*.js*", + "dist/**/*.mjs*", + "dist/**/*.d*" + ], + "engines": { + "node": ">=v14.0.0", + "npm": ">=7.0.0" + }, + "keywords": [ + "@sapphire/shapeshift", + "shapeshift", + "bot", + "typescript", + "ts", + "yarn", + "sapphire", + "schema", + "validation", + "type-checking", + "checking", + "input-validation", + "runtime-validation", + "ow", + "type-validation", + "zod" + ], + "bugs": { + "url": "https://github.com/sapphiredev/shapeshift/issues" + }, + "commitlint": { + "extends": [ + "@commitlint/config-conventional" + ] + }, + "lint-staged": { + "*.{mjs,js,ts}": "eslint --fix --ext mjs,js,ts" + }, + "config": { + "commitizen": { + "path": "./node_modules/cz-conventional-changelog" + } + }, + "publishConfig": { + "access": "public" + }, + "resolutions": { + "ansi-regex": "^5.0.1", + "minimist": "^1.2.8" + }, + "packageManager": "yarn@3.6.0" +}
\ No newline at end of file |