@modulify/validator 0.3.0 → 0.3.1

package/dist/assertions.mjs

@@ -1,3 +1,280 @@
-import { a as refine, t as assert } from "./assert-CzMg5aO7.mjs";
-import { A as startsWith, C as isSafeInteger, D as isValidDate, E as isSymbol, O as multipleOf, S as isRegExp, T as isString, _ as isMap, a as hasValue, b as isNumber, c as isBoolean, d as isEmail, f as isError, g as isInteger, h as isFunction, i as hasSize, k as oneOf, l as isDate, m as isFiniteNumber, n as hasLength, o as isBigInt, p as isFile, r as hasPattern, s as isBlob, t as endsWith, u as isDefined, v as isNaN, w as isSet, x as isPromiseLike, y as isNull } from "./assertions-DPYCHREw.mjs";
+import { assert, createRefinement, refine } from "./assert.mjs";
+import { endsWith as endsWith$1, inRange, isEqual, isGte, isLte, isMultipleOf, matchesPattern, startsWith as startsWith$1 } from "./checkers.mjs";
+import { length, size } from "./extractors.mjs";
+import { isArray, isBigInt as isBigInt$1, isBlob as isBlob$1, isBoolean as isBoolean$1, isDate as isDate$1, isEmail as isEmail$1, isError as isError$1, isFile as isFile$1, isFiniteNumber as isFiniteNumber$1, isFunction as isFunction$1, isInteger as isInteger$1, isMap as isMap$1, isNaN as isNaN$1, isNull as isNull$1, isNumber as isNumber$1, isPromiseLike as isPromiseLike$1, isRegExp as isRegExp$1, isSafeInteger as isSafeInteger$1, isSet as isSet$1, isString as isString$1, isSymbol as isSymbol$1, isValidDate as isValidDate$1 } from "./predicates.mjs";
+//#region src/assertions.ts
+var buildLengthConstraints = (options) => {
+	const { exact = null, max = null, min = null, range = null } = options;
+	const constraints = [];
+	if (exact !== null) constraints.push([
+		length,
+		isEqual,
+		"length.exact",
+		exact
+	]);
+	if (max !== null) constraints.push([
+		length,
+		isLte,
+		"length.max",
+		max
+	]);
+	if (min !== null) constraints.push([
+		length,
+		isGte,
+		"length.min",
+		min
+	]);
+	if (range !== null) constraints.push([
+		length,
+		inRange,
+		"length.range",
+		range
+	]);
+	return constraints;
+};
+var buildSizeConstraints = (options) => {
+	const { exact = null, max = null, min = null, range = null } = options;
+	const constraints = [];
+	if (exact !== null) constraints.push([
+		size,
+		isEqual,
+		"size.exact",
+		exact
+	]);
+	if (max !== null) constraints.push([
+		size,
+		isLte,
+		"size.max",
+		max
+	]);
+	if (min !== null) constraints.push([
+		size,
+		isGte,
+		"size.min",
+		min
+	]);
+	if (range !== null) constraints.push([
+		size,
+		inRange,
+		"size.range",
+		range
+	]);
+	return constraints;
+};
+var buildValueConstraints = (options) => {
+	const { exact = null, max = null, min = null, range = null } = options;
+	const constraints = [];
+	if (exact !== null) constraints.push([
+		(value) => value,
+		isEqual,
+		"number.exact",
+		exact
+	]);
+	if (max !== null) constraints.push([
+		(value) => value,
+		isLte,
+		"number.max",
+		max
+	]);
+	if (min !== null) constraints.push([
+		(value) => value,
+		isGte,
+		"number.min",
+		min
+	]);
+	if (range !== null) constraints.push([
+		(value) => value,
+		inRange,
+		"number.range",
+		range
+	]);
+	return constraints;
+};
+var isBoolean = /* @__PURE__ */ assert(isBoolean$1, {
+	name: "isBoolean",
+	bail: true,
+	code: "type.boolean"
+});
+var isBigInt = /* @__PURE__ */ assert(isBigInt$1, {
+	name: "isBigInt",
+	bail: true,
+	code: "type.bigint"
+});
+var isBlob = /* @__PURE__ */ assert(isBlob$1, {
+	name: "isBlob",
+	bail: true,
+	code: "type.blob"
+});
+var isDate = /* @__PURE__ */ assert(isDate$1, {
+	name: "isDate",
+	bail: true,
+	code: "type.date"
+});
+var isDefined = /* @__PURE__ */ assert((value) => value !== void 0, {
+	name: "isDefined",
+	bail: true,
+	code: "value.defined"
+});
+var isEmail = /* @__PURE__ */ assert(isEmail$1, {
+	name: "isEmail",
+	bail: true,
+	code: "string.email"
+});
+var isError = /* @__PURE__ */ assert(isError$1, {
+	name: "isError",
+	bail: true,
+	code: "type.error"
+});
+var isFiniteNumber = /* @__PURE__ */ assert(isFiniteNumber$1, {
+	name: "isFiniteNumber",
+	bail: true,
+	code: "number.finite"
+});
+var isFile = /* @__PURE__ */ assert(isFile$1, {
+	name: "isFile",
+	bail: true,
+	code: "type.file"
+});
+var isFunction = /* @__PURE__ */ assert(isFunction$1, {
+	name: "isFunction",
+	bail: true,
+	code: "type.function"
+});
+var isInteger = /* @__PURE__ */ assert(isInteger$1, {
+	name: "isInteger",
+	bail: true,
+	code: "number.integer"
+});
+var isMap = /* @__PURE__ */ assert(isMap$1, {
+	name: "isMap",
+	bail: true,
+	code: "type.map"
+});
+var isNaN = /* @__PURE__ */ assert(isNaN$1, {
+	name: "isNaN",
+	bail: true,
+	code: "number.nan"
+});
+var isNull = /* @__PURE__ */ assert(isNull$1, {
+	name: "isNull",
+	bail: true,
+	code: "type.null"
+});
+var isNumber = /* @__PURE__ */ assert(isNumber$1, {
+	name: "isNumber",
+	bail: true,
+	code: "type.number"
+});
+var isPromiseLike = /* @__PURE__ */ assert(isPromiseLike$1, {
+	name: "isPromiseLike",
+	bail: true,
+	code: "type.promise-like"
+});
+var isRegExp = /* @__PURE__ */ assert(isRegExp$1, {
+	name: "isRegExp",
+	bail: true,
+	code: "type.regexp"
+});
+var isSafeInteger = /* @__PURE__ */ assert(isSafeInteger$1, {
+	name: "isSafeInteger",
+	bail: true,
+	code: "number.safe-integer"
+});
+var isSet = /* @__PURE__ */ assert(isSet$1, {
+	name: "isSet",
+	bail: true,
+	code: "type.set"
+});
+var isString = /* @__PURE__ */ assert(isString$1, {
+	name: "isString",
+	bail: true,
+	code: "type.string"
+});
+var isSymbol = /* @__PURE__ */ assert(isSymbol$1, {
+	name: "isSymbol",
+	bail: true,
+	code: "type.symbol"
+});
+var isValidDate = /* @__PURE__ */ assert(isValidDate$1, {
+	name: "isValidDate",
+	bail: true,
+	code: "date.valid"
+});
+var hasLength = (options = {}) => {
+	const { bail = false } = options;
+	const constraints = buildLengthConstraints(options);
+	return /* @__PURE__ */ createRefinement({
+		name: "hasLength",
+		bail,
+		code: "length.unsupported-type"
+	}, constraints);
+};
+var hasSize = (options = {}) => {
+	const { bail = false } = options;
+	const constraints = buildSizeConstraints(options);
+	return /* @__PURE__ */ createRefinement({
+		name: "hasSize",
+		bail,
+		code: "size.unsupported-type"
+	}, constraints);
+};
+var hasPattern = (pattern, { bail = false } = {}) => /* @__PURE__ */ createRefinement({
+	name: "hasPattern",
+	bail,
+	code: "string.unsupported-type"
+}, [[
+	(value) => value,
+	matchesPattern,
+	"string.pattern",
+	pattern
+]]);
+var startsWith = (prefix, { bail = false } = {}) => /* @__PURE__ */ createRefinement({
+	name: "startsWith",
+	bail,
+	code: "string.unsupported-type"
+}, [[
+	(value) => value,
+	startsWith$1,
+	"string.starts-with",
+	prefix
+]]);
+var endsWith = (suffix, { bail = false } = {}) => /* @__PURE__ */ createRefinement({
+	name: "endsWith",
+	bail,
+	code: "string.unsupported-type"
+}, [[
+	(value) => value,
+	endsWith$1,
+	"string.ends-with",
+	suffix
+]]);
+var hasValue = (options = {}) => {
+	const { bail = false } = options;
+	const constraints = buildValueConstraints(options);
+	return /* @__PURE__ */ createRefinement({
+		name: "hasValue",
+		bail,
+		code: "number.unsupported-type"
+	}, constraints);
+};
+var multipleOf = (step, { bail = false } = {}) => /* @__PURE__ */ createRefinement({
+	name: "multipleOf",
+	bail,
+	code: "number.unsupported-type"
+}, [[
+	(value) => value,
+	isMultipleOf,
+	"number.multiple-of",
+	step
+]]);
+var oneOf = (values, { equalTo = (a, b) => a === b, bail = false } = {}) => {
+	const haystack = isArray(values) ? values : Object.values(values);
+	return /* @__PURE__ */ assert((value) => haystack.some((item) => equalTo(item, value)), {
+		name: "oneOf",
+		bail,
+		code: "value.one-of",
+		args: [haystack]
+	});
+};
+//#endregion
 export { assert, endsWith, hasLength, hasPattern, hasSize, hasValue, isBigInt, isBlob, isBoolean, isDate, isDefined, isEmail, isError, isFile, isFiniteNumber, isFunction, isInteger, isMap, isNaN, isNull, isNumber, isPromiseLike, isRegExp, isSafeInteger, isSet, isString, isSymbol, isValidDate, multipleOf, oneOf, refine, startsWith };

package/dist/checkers.cjs

@@ -0,0 +1,23 @@
+//#region src/checkers.ts
+var isEqual = (value, exact) => value === exact;
+var isGte = (value, min) => value >= min;
+var isLte = (value, max) => value <= max;
+var inRange = (value, [min, max]) => value >= min && value <= max;
+var startsWith = (value, prefix) => value.startsWith(prefix);
+var endsWith = (value, suffix) => value.endsWith(suffix);
+var matchesPattern = (value, pattern) => new RegExp(pattern.source, pattern.flags).test(value);
+var isMultipleOf = (value, step) => {
+	if (step === 0) return false;
+	const quotient = value / step;
+	const delta = Math.abs(quotient - Math.round(quotient));
+	return Number.isFinite(quotient) && delta <= Number.EPSILON * Math.max(1, Math.abs(quotient)) * 16;
+};
+//#endregion
+exports.endsWith = endsWith;
+exports.inRange = inRange;
+exports.isEqual = isEqual;
+exports.isGte = isGte;
+exports.isLte = isLte;
+exports.isMultipleOf = isMultipleOf;
+exports.matchesPattern = matchesPattern;
+exports.startsWith = startsWith;

package/dist/checkers.mjs

@@ -0,0 +1,16 @@
+//#region src/checkers.ts
+var isEqual = (value, exact) => value === exact;
+var isGte = (value, min) => value >= min;
+var isLte = (value, max) => value <= max;
+var inRange = (value, [min, max]) => value >= min && value <= max;
+var startsWith = (value, prefix) => value.startsWith(prefix);
+var endsWith = (value, suffix) => value.endsWith(suffix);
+var matchesPattern = (value, pattern) => new RegExp(pattern.source, pattern.flags).test(value);
+var isMultipleOf = (value, step) => {
+	if (step === 0) return false;
+	const quotient = value / step;
+	const delta = Math.abs(quotient - Math.round(quotient));
+	return Number.isFinite(quotient) && delta <= Number.EPSILON * Math.max(1, Math.abs(quotient)) * 16;
+};
+//#endregion
+export { endsWith, inRange, isEqual, isGte, isLte, isMultipleOf, matchesPattern, startsWith };

package/dist/combinators.cjs

@@ -1,11 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_assert = require("./assert-BDOtHdLx.cjs");
+const require_constraints = require("./constraints.cjs");
+const require_metadata = require("./metadata.cjs");
+const require_assert = require("./assert.cjs");
 const require_predicates = require("./predicates.cjs");
 //#region src/combinators.ts
 var describeConstraintMap = (constraints) => {
 	const described = {};
 	Reflect.ownKeys(constraints).forEach((key) => {
-		described[key] = require_assert.describeConstraints(constraints[key]);
+		described[key] = require_metadata.describeConstraints(constraints[key]);
 	});
 	return described;
 };
@@ -20,16 +22,16 @@ var normalizeAsyncRuleDescriptor = (descriptor) => ({
 	...normalizeRuleDescriptor(descriptor),
 	async: true
 });
-var passthrough = (kind, accepts, constraints) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+var passthrough = (kind, accepts, constraints) => /* @__PURE__ */ require_metadata.attachConstraintDescriptor({
 	check(value) {
-		return accepts(value) || require_assert.matchesConstraints(value, constraints);
+		return accepts(value) || require_constraints.matchesConstraints(value, constraints);
 	},
 	run(validate, value, path) {
 		return accepts(value) ? [] : [validate(value, constraints, path)];
 	}
 }, () => ({
 	kind,
-	child: require_assert.describeConstraints(constraints)
+	child: require_metadata.describeConstraints(constraints)
 }));
 var keysOf = (value) => Object.keys(value);
 var hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
@@ -76,7 +78,7 @@ var getPathValue = (value, path) => path.reduce((current, key) => {
 var toPath = (selector) => typeof selector === "object" ? [...selector] : [selector];
 var toShapeRefinementViolations = (value, path, result) => {
 	if (result === null || result === void 0) return [];
-	return require_assert.arrayify(result).filter((issue) => issue !== null && issue !== void 0).map((issue) => {
+	return require_constraints.arrayify(result).filter((issue) => issue !== null && issue !== void 0).map((issue) => {
 		const issuePath = issue.path ? [...issue.path] : [];
 		return {
 			value: issue.value ?? getPathValue(value, issuePath),
@@ -106,11 +108,11 @@ var createObjectShape = (descriptor, unknownKeys, refinements, rules) => {
 	const keys = keysOf(descriptor);
 	const addAsyncRefinement = (refinement, ruleDescriptor = { kind: "refine" }) => createObjectShape(descriptor, unknownKeys, [...refinements, refinement], [...rules, normalizeAsyncRuleDescriptor(ruleDescriptor)]);
 	const addSyncRefinement = (refinement, ruleDescriptor = { kind: "refine" }) => createObjectShape(descriptor, unknownKeys, [...refinements, refinement], [...rules, normalizeRuleDescriptor(ruleDescriptor)]);
-	return /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+	return /* @__PURE__ */ require_metadata.attachConstraintDescriptor({
 		descriptor,
 		unknownKeys,
 		check(value) {
-			return require_predicates.isRecord(value) && keys.every((key) => require_assert.matchesConstraints(value[key], descriptor[key])) && (unknownKeys === "passthrough" || !hasUnknownKeys(value, descriptor)) && collectShapeRefinementViolations(value, [], refinements).length === 0;
+			return require_predicates.isRecord(value) && keys.every((key) => require_constraints.matchesConstraints(value[key], descriptor[key])) && (unknownKeys === "passthrough" || !hasUnknownKeys(value, descriptor)) && collectShapeRefinementViolations(value, [], refinements).length === 0;
 		},
 		run(validate, value, path) {
 			if (!require_predicates.isRecord(value)) return [[{
@@ -197,9 +199,9 @@ var collectUnionViolations = (branches, validate, value, path) => {
 	});
 	return toUnionFailure(branches, value, path, branchResults);
 };
-var each = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+var each = (constraints) => /* @__PURE__ */ require_metadata.attachConstraintDescriptor({
 	check(value) {
-		return require_predicates.isArray(value) && value.every((item) => require_assert.matchesConstraints(item, constraints));
+		return require_predicates.isArray(value) && value.every((item) => require_constraints.matchesConstraints(item, constraints));
 	},
 	run(validate, value, path) {
 		return require_predicates.isArray(value) ? value.map((item, index) => validate(item, constraints, [...path, index])) : [[{
@@ -215,11 +217,11 @@ var each = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDescr
 	}
 }, () => ({
 	kind: "each",
-	item: require_assert.describeConstraints(constraints)
+	item: require_metadata.describeConstraints(constraints)
 }));
-var tuple = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+var tuple = (constraints) => /* @__PURE__ */ require_metadata.attachConstraintDescriptor({
 	check(value) {
-		return require_predicates.isArray(value) && value.length === constraints.length && constraints.every((constraint, index) => require_assert.matchesConstraints(value[index], constraint));
+		return require_predicates.isArray(value) && value.length === constraints.length && constraints.every((constraint, index) => require_constraints.matchesConstraints(value[index], constraint));
 	},
 	run(validate, value, path) {
 		if (!require_predicates.isArray(value)) return [[{
@@ -246,24 +248,24 @@ var tuple = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDesc
 	}
 }, () => ({
 	kind: "tuple",
-	items: constraints.map((constraint) => require_assert.describeConstraints(constraint))
+	items: constraints.map((constraint) => require_metadata.describeConstraints(constraint))
 }));
-var union = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+var union = (constraints) => /* @__PURE__ */ require_metadata.attachConstraintDescriptor({
 	check(value) {
-		return constraints.some((constraint) => require_assert.matchesConstraints(value, constraint));
+		return constraints.some((constraint) => require_constraints.matchesConstraints(value, constraint));
 	},
 	run(validate, value, path) {
 		return [collectUnionViolations(constraints, validate, value, path)];
 	}
 }, () => ({
 	kind: "union",
-	branches: constraints.map((constraint) => require_assert.describeConstraints(constraint))
+	branches: constraints.map((constraint) => require_metadata.describeConstraints(constraint))
 }));
-var discriminatedUnion = (key, variants) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+var discriminatedUnion = (key, variants) => /* @__PURE__ */ require_metadata.attachConstraintDescriptor({
 	check(value) {
 		if (!require_predicates.isRecord(value)) return false;
 		const discriminator = value[key];
-		return Object.prototype.hasOwnProperty.call(variants, discriminator) && require_assert.matchesConstraints(value, variants[discriminator]);
+		return Object.prototype.hasOwnProperty.call(variants, discriminator) && require_constraints.matchesConstraints(value, variants[discriminator]);
 	},
 	run(validate, value, path) {
 		if (!require_predicates.isRecord(value)) return [[{
@@ -294,9 +296,9 @@ var discriminatedUnion = (key, variants) => /* @__PURE__ */ require_assert.attac
 	key,
 	variants: describeConstraintMap(variants)
 }));
-var record = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+var record = (constraints) => /* @__PURE__ */ require_metadata.attachConstraintDescriptor({
 	check(value) {
-		return require_predicates.isRecord(value) && Object.values(value).every((item) => require_assert.matchesConstraints(item, constraints));
+		return require_predicates.isRecord(value) && Object.values(value).every((item) => require_constraints.matchesConstraints(item, constraints));
 	},
 	run(validate, value, path) {
 		if (!require_predicates.isRecord(value)) return [[{
@@ -313,7 +315,7 @@ var record = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDes
 	}
 }, () => ({
 	kind: "record",
-	values: require_assert.describeConstraints(constraints)
+	values: require_metadata.describeConstraints(constraints)
 }));
 var shape = (descriptor) => {
 	return /* @__PURE__ */ createObjectShape(descriptor, "passthrough", [], []);

package/dist/combinators.mjs

@@ -1,4 +1,6 @@
-import { f as arrayify, m as matchesConstraints, s as attachConstraintDescriptor, t as assert, u as describeConstraints } from "./assert-CzMg5aO7.mjs";
+import { arrayify, matchesConstraints } from "./constraints.mjs";
+import { attachConstraintDescriptor, describeConstraints } from "./metadata.mjs";
+import { assert } from "./assert.mjs";
 import { isArray, isExact, isNull, isRecord, isUndefined } from "./predicates.mjs";
 //#region src/combinators.ts
 var describeConstraintMap = (constraints) => {

package/dist/constraints.cjs

@@ -0,0 +1,23 @@
+const require_assert = require("./assert.cjs");
+//#region src/constraints.ts
+var isValidator = (constraint) => "run" in constraint;
+function arrayify(value) {
+	return Array.isArray(value) ? [...value] : [value];
+}
+function matchesConstraints(value, constraints) {
+	let establishedDomain = false;
+	return arrayify(constraints).every((constraint) => {
+		if (isValidator(constraint)) {
+			establishedDomain = false;
+			return constraint.check(value);
+		}
+		if (!establishedDomain && require_assert.isRefinementAssertion(constraint)) return false;
+		const matched = establishedDomain && require_assert.isRefinementAssertion(constraint) ? require_assert.checkRefinementAssertion(constraint, value) : constraint.check(value);
+		if (matched) establishedDomain = true;
+		return matched;
+	});
+}
+//#endregion
+exports.arrayify = arrayify;
+exports.isValidator = isValidator;
+exports.matchesConstraints = matchesConstraints;

package/dist/constraints.mjs

@@ -0,0 +1,21 @@
+import { checkRefinementAssertion, isRefinementAssertion } from "./assert.mjs";
+//#region src/constraints.ts
+var isValidator = (constraint) => "run" in constraint;
+function arrayify(value) {
+	return Array.isArray(value) ? [...value] : [value];
+}
+function matchesConstraints(value, constraints) {
+	let establishedDomain = false;
+	return arrayify(constraints).every((constraint) => {
+		if (isValidator(constraint)) {
+			establishedDomain = false;
+			return constraint.check(value);
+		}
+		if (!establishedDomain && isRefinementAssertion(constraint)) return false;
+		const matched = establishedDomain && isRefinementAssertion(constraint) ? checkRefinementAssertion(constraint, value) : constraint.check(value);
+		if (matched) establishedDomain = true;
+		return matched;
+	});
+}
+//#endregion
+export { arrayify, isValidator, matchesConstraints };

package/dist/extractors.cjs

@@ -0,0 +1,6 @@
+//#region src/extractors.ts
+var length = (value) => value.length;
+var size = (value) => value.size;
+//#endregion
+exports.length = length;
+exports.size = size;

package/dist/extractors.mjs

@@ -0,0 +1,5 @@
+//#region src/extractors.ts
+var length = (value) => value.length;
+var size = (value) => value.size;
+//#endregion
+export { length, size };

package/dist/index.cjs

@@ -1,92 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_assert = require("./assert-BDOtHdLx.cjs");
-const require_assertions = require("./assertions-nfOKqcjs.cjs");
+const require_constraints = require("./constraints.cjs");
+const require_metadata = require("./metadata.cjs");
+const require_assert = require("./assert.cjs");
+const require_assertions = require("./assertions.cjs");
 const require_combinators = require("./combinators.cjs");
-//#region src/violations.ts
-var ROOT_PATH = Object.freeze([]);
-var normalizePath = (path) => path ?? ROOT_PATH;
-var isSamePath = (left, right = ROOT_PATH) => {
-	const normalizedLeft = normalizePath(left);
-	if (normalizedLeft.length !== right.length) return false;
-	return normalizedLeft.every((part, index) => Object.is(part, right[index]));
-};
-var isPathPrefix = (path, prefix) => {
-	if (prefix.length > path.length) return false;
-	return prefix.every((part, index) => Object.is(part, path[index]));
-};
-var createTreeState = (path) => ({
-	path: Object.freeze([...path]),
-	self: [],
-	subtree: [],
-	children: /* @__PURE__ */ new Map()
-});
-var TreeNode = class TreeNode {
-	constructor(state) {
-		this.path = state.path;
-		this.self = new ViolationCollection(state.self);
-		this.subtree = new ViolationCollection(state.subtree);
-		this.children = new Map([...state.children.entries()].map(([key, child]) => [key, new TreeNode(child)]));
-	}
-	at(path) {
-		if (!isPathPrefix(path, this.path)) return;
-		if (path.length === this.path.length) return this;
-		return this.children.get(path[this.path.length])?.at(path);
-	}
-};
-var buildTree = (violations) => {
-	const root = createTreeState(ROOT_PATH);
-	violations.forEach((violation) => {
-		const path = normalizePath(violation.path);
-		root.subtree.push(violation);
-		if (path.length === 0) {
-			root.self.push(violation);
-			return;
-		}
-		let current = root;
-		const currentPath = [];
-		path.forEach((segment, index) => {
-			currentPath.push(segment);
-			let child = current.children.get(segment);
-			if (!child) {
-				child = createTreeState(currentPath);
-				current.children.set(segment, child);
-			}
-			child.subtree.push(violation);
-			if (index === path.length - 1) child.self.push(violation);
-			current = child;
-		});
-	});
-	return new TreeNode(root);
-};
-var ViolationCollection = class ViolationCollection {
-	constructor(violations) {
-		this.violations = [...violations];
-		this.size = this.violations.length;
-	}
-	[Symbol.iterator]() {
-		return this.violations[Symbol.iterator]();
-	}
-	forEach(callback) {
-		this.violations.forEach((violation, index) => callback(violation, index, this));
-	}
-	map(callback) {
-		return this.violations.map((violation, index) => callback(violation, index, this));
-	}
-	at(path) {
-		return new ViolationCollection(this.violations.filter((violation) => isSamePath(violation.path, path)));
-	}
-	tree() {
-		return buildTree(this.violations);
-	}
-};
-var collection = (violations) => new ViolationCollection(violations);
-//#endregion
+const require_violations = require("./violations.cjs");
 //#region src/index.ts
 var collectViolations = async (value, constraints, path = []) => {
 	const validations = [];
 	let establishedAssertionDomain = false;
-	for (const c of require_assert.arrayify(constraints)) {
-		if (require_assert.isValidator(c)) {
+	for (const c of require_constraints.arrayify(constraints)) {
+		if (require_constraints.isValidator(c)) {
 			establishedAssertionDomain = false;
 			validations.push(...c.run(collectViolations, value, path).map((v) => v instanceof Promise ? v : Promise.resolve(v)));
 			continue;
@@ -114,8 +38,8 @@ collectViolations.sync = false;
 var collectViolationsSync = (value, constraints, path = []) => {
 	const violations = [];
 	let establishedAssertionDomain = false;
-	for (const c of require_assert.arrayify(constraints)) {
-		if (require_assert.isValidator(c)) {
+	for (const c of require_constraints.arrayify(constraints)) {
+		if (require_constraints.isValidator(c)) {
 			establishedAssertionDomain = false;
 			violations.push(...c.run(collectViolationsSync, value, path));
 			continue;
@@ -176,11 +100,11 @@ var validate = /* @__PURE__ */ Object.assign(async (value, constraints) => {
 	return toResult(value, collectViolationsSync(value, constraints));
 } });
 //#endregion
-exports.ViolationCollection = ViolationCollection;
+exports.ViolationCollection = require_violations.ViolationCollection;
 exports.assert = require_assert.assert;
-exports.collection = collection;
-exports.custom = require_assert.custom;
-exports.describe = require_assert.describe;
+exports.collection = require_violations.collection;
+exports.custom = require_metadata.custom;
+exports.describe = require_metadata.describe;
 exports.discriminatedUnion = require_combinators.discriminatedUnion;
 exports.each = require_combinators.each;
 exports.endsWith = require_assertions.endsWith;
@@ -212,7 +136,7 @@ exports.isString = require_assertions.isString;
 exports.isSymbol = require_assertions.isSymbol;
 exports.isValidDate = require_assertions.isValidDate;
 exports.matches = matches;
-exports.meta = require_assert.meta;
+exports.meta = require_metadata.meta;
 exports.multipleOf = require_assertions.multipleOf;
 exports.nullable = require_combinators.nullable;
 exports.nullish = require_combinators.nullish;