@oscarpalmer/jhunal 0.8.0 → 0.10.0

package/dist/jhunal.full.js

@@ -1,77 +1,30 @@
-const EXPRESSION_HAS_NUMBER = /\d+/;
-const EXPRESSION_INDEX = /\.\d+$/;
-const EXPRESSION_PROPERTY = /\.\$(required|type)(\.|$)/;
-const PROPERTY_REQUIRED = "$required";
-const PROPERTY_TYPE = "$type";
-const SCHEMATIC_NAME = "$schematic";
-const TYPE_OBJECT = "object";
-const TYPE_UNDEFINED = "undefined";
-const TYPE_ALL = new Set([
-	"array",
-	"bigint",
-	"boolean",
-	"date",
-	"function",
-	"null",
-	"number",
-	"string",
-	"symbol",
-	TYPE_OBJECT,
-	TYPE_UNDEFINED
-]);
-function isConstructor$1(value) {
-	return typeof value === "function" && value.prototype !== void 0;
-}
-function isInstance(constructor) {
-	if (!isConstructor$1(constructor)) throw new TypeError("Expected a constructor function");
-	return (value) => {
-		return value instanceof constructor;
-	};
-}
-function isSchematic(value) {
-	return typeof value === "object" && value !== null && SCHEMATIC_NAME in value && value[SCHEMATIC_NAME] === true;
-}
-function aggregate(type, array, key) {
-	const length = Array.isArray(array) ? array.length : 0;
-	if (length === 0) return {
-		count: 0,
-		value: NaN
-	};
-	const aggregator = aggregators[type];
-	const isCallback = typeof key === "function";
-	let counted = 0;
-	let aggregated = NaN;
-	let notNumber = true;
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		const value = isCallback ? key(item, index, array) : item[key] ?? item;
-		if (typeof value === "number" && !Number.isNaN(value)) {
-			aggregated = aggregator(aggregated, value, notNumber);
-			counted += 1;
-			notNumber = false;
-		}
-	}
-	return {
-		count: counted,
-		value: aggregated
-	};
-}
-function max(array, key) {
-	return getAggregated("max", array, key);
+/**
+* Is the value an array or a record?
+* @param value Value to check
+* @returns `true` if the value is an array or a record, otherwise `false`
+*/
+function isArrayOrPlainObject(value) {
+	return Array.isArray(value) || isPlainObject(value);
 }
-function calculateSum(current, value, notNumber) {
-	return notNumber ? value : current + value;
+/**
+* Is the value a constructor function?
+* @param value Value to check
+* @returns `true` if the value is a constructor function, otherwise `false`
+*/
+function isConstructor(value) {
+	return typeof value === "function" && value.prototype?.constructor === value;
 }
-function getAggregated(type, array, key) {
-	const aggregated = aggregate(type, array, key);
-	return aggregated.count > 0 ? aggregated.value : NaN;
+/**
+* Is the value a plain object?
+* @param value Value to check
+* @returns `true` if the value is a plain object, otherwise `false`
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
 }
-var aggregators = {
-	average: calculateSum,
-	max: (current, value, notNumber) => notNumber || value > current ? value : current,
-	min: (current, value, notNumber) => notNumber || value < current ? value : current,
-	sum: calculateSum
-};
 function compact(array, strict) {
 	if (!Array.isArray(array)) return [];
 	if (strict === true) return array.filter(Boolean);
@@ -105,536 +58,36 @@ function getString(value) {
 function join(value, delimiter) {
 	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
 }
-/**
-* Split a string into words _(and other readable parts)_
-* @param value Original string
-* @returns Array of words found in the string
-*/
-function words(value) {
-	return typeof value === "string" ? value.match(EXPRESSION_WORDS) ?? [] : [];
-}
-var EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
-/**
-* Is the value an array or a record?
-* @param value Value to check
-* @returns `true` if the value is an array or a record, otherwise `false`
-*/
-function isArrayOrPlainObject(value) {
-	return Array.isArray(value) || isPlainObject(value);
-}
-/**
-* Is the value a constructor?
-* @param value Value to check
-* @returns `true` if the value is a constructor, otherwise `false`
-*/
-function isConstructor(value) {
-	return typeof value === "function" && EXPRESSION_CONSTRUCTOR.test(value.name);
-}
-/**
-* Is the value a plain object?
-* @param value Value to check
-* @returns `true` if the value is a plain object, otherwise `false`
-*/
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
-}
-/**
-* Is the value a typed array?
-* @param value Value to check
-* @returns `true` if the value is a typed array, otherwise `false`
-*/
-function isTypedArray(value) {
-	TYPED_ARRAYS ??= new Set([
-		Int8Array,
-		Uint8Array,
-		Uint8ClampedArray,
-		Int16Array,
-		Uint16Array,
-		Int32Array,
-		Uint32Array,
-		Float32Array,
-		Float64Array,
-		BigInt64Array,
-		BigUint64Array
-	]);
-	return TYPED_ARRAYS.has(value?.constructor);
-}
-var EXPRESSION_CONSTRUCTOR = /^[A-Z][A-Za-z0-9]*$/;
-var TYPED_ARRAYS;
-function getCompareHandlers(owner, options) {
-	const { get, register, unregister } = getHandlers(owner, options);
-	return {
-		register,
-		unregister,
-		handle(first, second, ...parameters) {
-			const handler = get(first, second);
-			if (handler == null) return options.callback(first, second, ...parameters);
-			return typeof handler === "function" ? handler(first, second) : first[handler](second);
-		}
-	};
-}
-function getHandlers(owner, options) {
-	const handlers = /* @__PURE__ */ new WeakMap();
-	return {
-		get(first, second) {
-			if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return handlers.get(first.constructor);
-		},
-		register(constructor, handler) {
-			if (!isConstructor(constructor) || handler === owner) return;
-			let actual = handler ?? options.method;
-			if (typeof actual !== "function" && typeof actual !== "string") return;
-			if (typeof actual === "string") actual = typeof constructor.prototype[actual] === "function" ? actual : void 0;
-			if (actual != null) handlers.set(constructor, actual);
-		},
-		unregister(constructor) {
-			handlers.delete(constructor);
-		}
-	};
-}
-function getSelfHandlers(owner, options) {
-	const { get, register, unregister } = getHandlers(owner, options);
-	return {
-		register,
-		unregister,
-		handle(value, ...parameters) {
-			const handler = get(value, value);
-			if (handler == null) return options.callback(value, ...parameters);
-			return typeof handler === "function" ? handler(value) : value[handler]();
-		}
-	};
-}
-function isConstructable(value) {
-	return typeof value === "object" && value !== null;
-}
-/**
-* Compare two values _(for sorting purposes)_
-* @param first First value
-* @param second Second value
-* @returns `0` if equal; `-1` first comes before second; `1` first comes after second
-*/
-function compare(first, second) {
-	if (Object.is(first, second)) return 0;
-	if (first == null) return -1;
-	if (second == null) return 1;
-	let comparison = compareValue(first, second, false);
-	if (comparison != null) return comparison;
-	const firstParts = getComparisonParts(first);
-	const secondParts = getComparisonParts(second);
-	const length = max([firstParts.length, secondParts.length]);
-	const lastIndex = length - 1;
-	for (let index = 0; index < length; index += 1) {
-		const firstPart = firstParts[index];
-		const secondPart = secondParts[index];
-		comparison = compareValue(firstPart, secondPart, true);
-		if (comparison === 0) {
-			if (index === lastIndex) break;
-			continue;
-		}
-		return comparison;
-	}
-	return 0;
-}
-compare.handlers = getCompareHandlers(compare, {
-	callback: (first, second, compareStrings) => {
-		if (compareStrings) return getString(first).localeCompare(getString(second));
-	},
-	method: "compare"
-});
-/**
-* Register a custom comparison handler for a class
-* @param constructor Class constructor
-* @param handler Method name or comparison function _(defaults to `compare`)_
-*/
-compare.register = function(constructor, handler) {
-	compare.handlers.register(constructor, handler);
-};
-/**
-* Unregister a custom comparison handler for a class
-* @param constructor Class constructor
-*/
-compare.unregister = compare.handlers.unregister;
-function compareNumbers(first, second) {
-	const firstNumber = Number(first);
-	const secondNumber = Number(second);
-	if (firstNumber === secondNumber) return 0;
-	return firstNumber > secondNumber ? 1 : -1;
-}
-function compareSymbols(first, second) {
-	return getString(first.description ?? first).localeCompare(getString(second.description ?? second));
-}
-function compareValue(first, second, compareStrings) {
-	const firstType = typeof first;
-	if (firstType === typeof second && firstType in comparators) return comparators[firstType](first, second);
-	if (first instanceof Date && second instanceof Date) return compareNumbers(first.getTime(), second.getTime());
-	return compare.handlers.handle(first, second, compareStrings);
-}
-function getComparisonParts(value) {
-	if (Array.isArray(value)) return value;
-	return typeof value === "object" ? [value] : words(getString(value));
-}
-var comparators = {
-	bigint: compareNumbers,
-	boolean: compareNumbers,
-	number: compareNumbers,
-	symbol: compareSymbols
-};
-/**
-* Chunk an array into smaller arrays
-* @param array Array to chunk
-* @param size Size of each chunk _(minimum is `1`, maximum is `5000`; defaults to `5000`)_
-* @returns Array of arrays
-*/
-function chunk(array, size) {
-	if (!Array.isArray(array)) return [];
-	if (array.length === 0) return [];
-	const { length } = array;
-	const actualSize = typeof size === "number" && size > 0 && size <= MAX_SIZE ? size : MAX_SIZE;
-	if (length <= actualSize) return [array];
-	const chunks = [];
-	let index = 0;
-	while (index < length) {
-		chunks.push(array.slice(index, index + actualSize));
-		index += actualSize;
-	}
-	return chunks;
-}
-var MAX_SIZE = 5e3;
-function equal(first, second, options) {
-	return equalValue(first, second, getEqualOptions(options));
-}
-function equalArray(first, second, options) {
-	const { length } = first;
-	if (length !== second.length) return false;
-	let offset = 0;
-	if (length >= ARRAY_THRESHOLD) {
-		offset = Math.round(length / ARRAY_PEEK_PERCENTAGE);
-		offset = offset > ARRAY_THRESHOLD ? ARRAY_THRESHOLD : offset;
-		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
-	}
-	const firstChunks = chunk(first.slice(offset, length - offset), ARRAY_THRESHOLD);
-	const secondChunks = chunk(second.slice(offset, length - offset), ARRAY_THRESHOLD);
-	const chunksLength = firstChunks.length;
-	for (let chunkIndex = 0; chunkIndex < chunksLength; chunkIndex += 1) {
-		const firstChunk = firstChunks[chunkIndex];
-		const secondChunk = secondChunks[chunkIndex];
-		const chunkLength = firstChunk.length;
-		for (let index = 0; index < chunkLength; index += 1) if (!equalValue(firstChunk[index], secondChunk[index], options)) return false;
-	}
-	return true;
-}
-function equalArrayBuffer(first, second, options) {
-	return first.byteLength === second.byteLength ? equalArray(new Uint8Array(first), new Uint8Array(second), options) : false;
-}
-function equalDataView(first, second, options) {
-	return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer, options) : false;
-}
-function equalMap(first, second, options) {
-	const { size } = first;
-	if (size !== second.size) return false;
-	const firstKeys = [...first.keys()];
-	const secondKeys = [...second.keys()];
-	if (firstKeys.some((key) => !secondKeys.includes(key))) return false;
-	for (let index = 0; index < size; index += 1) {
-		const key = firstKeys[index];
-		if (!equalValue(first.get(key), second.get(key), options)) return false;
-	}
-	return true;
-}
-function equalPlainObject(first, second, options) {
-	let firstKeys = [...Object.keys(first), ...Object.getOwnPropertySymbols(first)];
-	let secondKeys = [...Object.keys(second), ...Object.getOwnPropertySymbols(second)];
-	if (options.ignoreKeys.enabled || options.ignoreExpressions.enabled) {
-		firstKeys = firstKeys.filter((key) => filterKey(key, options));
-		secondKeys = secondKeys.filter((key) => filterKey(key, options));
-	}
-	const { length } = firstKeys;
-	if (length !== secondKeys.length || firstKeys.some((key) => !secondKeys.includes(key))) return false;
-	for (let index = 0; index < length; index += 1) {
-		const key = firstKeys[index];
-		if (!equalValue(first[key], second[key], options)) return false;
-	}
-	return true;
-}
-function equalProperties(first, second, properties, options) {
-	const { length } = properties;
-	for (let index = 0; index < length; index += 1) {
-		const property = properties[index];
-		if (!equalValue(first[property], second[property], options)) return false;
-	}
-	return true;
-}
-function equalSet(first, second, options) {
-	const { size } = first;
-	if (size !== second.size) return false;
-	const firstValues = [...first];
-	const secondValues = [...second];
-	for (let index = 0; index < size; index += 1) {
-		const firstValue = firstValues[index];
-		if (!secondValues.some((secondValue) => equalValue(firstValue, secondValue, options))) return false;
-	}
-	return true;
-}
-function equalTypedArray(first, second) {
-	if (first.constructor !== second.constructor) return false;
-	if (first.byteLength !== second.byteLength) return false;
-	const { length } = first;
-	for (let index = 0; index < length; index += 1) if (first[index] !== second[index]) return false;
-	return true;
-}
-function equalValue(first, second, options) {
-	if (options.relaxedNullish && first == null && second == null) return true;
-	switch (true) {
-		case Object.is(first, second): return true;
-		case first == null || second == null: return first === second;
-		case typeof first !== typeof second: return false;
-		case typeof first === "string" && options.ignoreCase === true: return Object.is(first.toLocaleLowerCase(), second.toLocaleLowerCase());
-		case first instanceof ArrayBuffer && second instanceof ArrayBuffer: return equalArrayBuffer(first, second, options);
-		case first instanceof Date && second instanceof Date: return Object.is(Number(first), Number(second));
-		case first instanceof DataView && second instanceof DataView: return equalDataView(first, second, options);
-		case first instanceof Error && second instanceof Error: return equalProperties(first, second, ["name", "message"], options);
-		case first instanceof Map && second instanceof Map: return equalMap(first, second, options);
-		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, ["source", "flags"], options);
-		case first instanceof Set && second instanceof Set: return equalSet(first, second, options);
-		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
-		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
-		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
-		default: return equal.handlers.handle(first, second, options);
-	}
-}
-equal.handlers = getCompareHandlers(equal, { callback: Object.is });
-/**
-* Create an equalizer with predefined options
-* @param options Comparison options
-* @returns Equalizer function
-*/
-equal.initialize = function(options) {
-	const actual = getEqualOptions(options);
-	const equalizer = (first, second) => equalValue(first, second, actual);
-	equalizer.register = equal.register;
-	equalizer.unregister = equal.unregister;
-	return equalizer;
-};
-/**
-* Register a equality comparison function for a specific class
-* @param constructor Class constructor
-* @param fn Comparison function
-*/
-equal.register = function(constructor, fn) {
-	equal.handlers.register(constructor, fn);
-};
-/**
-* Unregister a equality comparison handler for a specific class
-* @param constructor Class constructor
-*/
-equal.unregister = equal.handlers.unregister;
-function filterKey(key, options) {
-	if (typeof key !== "string") return true;
-	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
-	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
-	return true;
-}
-function getEqualOptions(input) {
-	const options = {
-		ignoreCase: false,
-		ignoreExpressions: {
-			enabled: false,
-			values: []
-		},
-		ignoreKeys: {
-			enabled: false,
-			values: /* @__PURE__ */ new Set()
-		},
-		relaxedNullish: false
-	};
-	if (typeof input === "boolean") {
-		options.ignoreCase = input;
-		return options;
-	}
-	if (!isPlainObject(input)) return options;
-	options.ignoreCase = typeof input.ignoreCase === "boolean" ? input.ignoreCase : false;
-	options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => key instanceof RegExp);
-	options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => typeof key === "string"));
-	options.ignoreExpressions.enabled = options.ignoreExpressions.values.length > 0;
-	options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
-	options.relaxedNullish = input.relaxedNullish === true;
-	return options;
-}
-var ARRAY_PEEK_PERCENTAGE = 10;
-var ARRAY_THRESHOLD = 100;
-function clone(value) {
-	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap());
-}
-clone.handlers = getSelfHandlers(clone, {
-	callback: tryStructuredClone,
-	method: "clone"
-});
-/**
-* Register a clone handler for a specific class
-* @param constructor Class constructor
-* @param handler Method name or clone function _(defaults to `clone`)_
-*/
-clone.register = function(constructor, handler) {
-	clone.handlers.register(constructor, handler);
-};
-/**
-* Unregister a clone handler for a specific class
-* @param constructor Class constructor
-*/
-clone.unregister = clone.handlers.unregister;
-function cloneArrayBuffer(value, depth, references) {
-	if (typeof depth === "number" && depth >= MAX_CLONE_DEPTH) return value;
-	const cloned = new ArrayBuffer(value.byteLength);
-	new Uint8Array(cloned).set(new Uint8Array(value));
-	references?.set(value, cloned);
-	return cloned;
-}
-function cloneDataView(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
-	const buffer = cloneArrayBuffer(value.buffer);
-	const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
-	references.set(value, cloned);
-	return cloned;
-}
-function cloneMapOrSet(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
-	const isMap = value instanceof Map;
-	const cloned = isMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Set();
-	const entries = [...value.entries()];
-	const { length } = entries;
-	for (let index = 0; index < length; index += 1) {
-		const entry = entries[index];
-		if (isMap) cloned.set(cloneValue(entry[0], depth + 1, references), cloneValue(entry[1], depth + 1, references));
-		else cloned.add(cloneValue(entry[0], depth + 1, references));
-	}
-	references.set(value, cloned);
-	return cloned;
-}
-function cloneNode(node, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return node;
-	const cloned = node.cloneNode(true);
-	references.set(node, cloned);
-	return cloned;
-}
-function clonePlainObject(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return Array.isArray(value) ? [...value] : { ...value };
-	const cloned = Array.isArray(value) ? [] : {};
-	const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
-	const { length } = keys;
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		cloned[key] = cloneValue(value[key], depth + 1, references);
-	}
-	references.set(value, cloned);
-	return cloned;
-}
-function cloneRegularExpression(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
-	const cloned = new RegExp(value.source, value.flags);
-	cloned.lastIndex = value.lastIndex;
-	references.set(value, cloned);
-	return cloned;
-}
-function cloneTypedArray(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
-	const cloned = new value.constructor(value);
-	references.set(value, cloned);
-	return cloned;
-}
-function cloneValue(value, depth, references) {
-	switch (true) {
-		case value == null: return value;
-		case typeof value === "bigint": return BigInt(value);
-		case typeof value === "boolean": return Boolean(value);
-		case typeof value === "function": return;
-		case typeof value === "number": return Number(value);
-		case typeof value === "string": return String(value);
-		case typeof value === "symbol": return Symbol(value.description);
-		case references.has(value): return references.get(value);
-		case value instanceof ArrayBuffer: return cloneArrayBuffer(value, depth, references);
-		case value instanceof DataView: return cloneDataView(value, depth, references);
-		case value instanceof Date: return new Date(value.getTime());
-		case value instanceof RegExp: return cloneRegularExpression(value, depth, references);
-		case value instanceof Map:
-		case value instanceof Set: return cloneMapOrSet(value, depth, references);
-		case value instanceof Node: return cloneNode(value, depth, references);
-		case isArrayOrPlainObject(value): return clonePlainObject(value, depth, references);
-		case isTypedArray(value): return cloneTypedArray(value, depth, references);
-		default: return clone.handlers.handle(value, depth, references);
-	}
-}
-function tryStructuredClone(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
-	try {
-		const cloned = structuredClone(value);
-		references.set(value, cloned);
-		return cloned;
-	} catch {
-		references.set(value, value);
-		return value;
-	}
-}
-var MAX_CLONE_DEPTH = 100;
-function getMergeOptions(options) {
-	const actual = {
-		replaceableObjects: void 0,
-		skipNullableInArrays: false
+const EXPRESSION_HAS_NUMBER = /\d+/;
+const EXPRESSION_INDEX = /\.\d+$/;
+const EXPRESSION_PROPERTY = /\.\$(required|type|validators)(\.|$)/;
+const PROPERTY_REQUIRED = "$required";
+const PROPERTY_TYPE = "$type";
+const PROPERTY_VALIDATORS = "$validators";
+const SCHEMATIC_NAME = "$schematic";
+const TYPE_OBJECT = "object";
+const TYPE_UNDEFINED = "undefined";
+const TYPE_ALL = new Set([
+	"array",
+	"bigint",
+	"boolean",
+	"date",
+	"function",
+	"null",
+	"number",
+	"string",
+	"symbol",
+	TYPE_OBJECT,
+	TYPE_UNDEFINED
+]);
+function isInstance(constructor) {
+	if (!isConstructor(constructor)) throw new TypeError("Expected a constructor function");
+	return (value) => {
+		return value instanceof constructor;
 	};
-	if (typeof options !== "object" || options == null) return actual;
-	actual.replaceableObjects = getReplaceableObjects(options.replaceableObjects);
-	actual.skipNullableInArrays = options.skipNullableInArrays === true;
-	return actual;
-}
-function getReplaceableObjects(value) {
-	const items = (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string" || item instanceof RegExp);
-	if (items.length > 0) return (name) => items.some((item) => typeof item === "string" ? item === name : item.test(name));
-}
-function handleMerge(values, options) {
-	return !Array.isArray(values) || values.length === 0 ? {} : mergeValues(values, options, true);
 }
-/**
-* Merge multiple arrays or objects into a single one
-* @param values Values to merge
-* @param options Merging options
-* @returns Merged value
-*/
-function merge(values, options) {
-	return handleMerge(values, getMergeOptions(options));
-}
-/**
-* Create a merger with predefined options
-* @param options Merging options
-* @returns Merger function
-*/
-merge.initialize = function(options) {
-	const actual = getMergeOptions(options);
-	return (values) => handleMerge(values, actual);
-};
-function mergeObjects(values, options, prefix) {
-	const { length } = values;
-	const isArray = values.every(Array.isArray);
-	const merged = isArray ? [] : {};
-	for (let outerIndex = 0; outerIndex < length; outerIndex += 1) {
-		const item = values[outerIndex];
-		const keys = Object.keys(item);
-		const size = keys.length;
-		for (let innerIndex = 0; innerIndex < size; innerIndex += 1) {
-			const key = keys[innerIndex];
-			const full = join([prefix, key], ".");
-			const next = item[key];
-			const previous = merged[key];
-			if (isArray && options.skipNullableInArrays && next == null) continue;
-			if (isArrayOrPlainObject(next) && isArrayOrPlainObject(previous) && !(options.replaceableObjects?.(full) ?? false)) merged[key] = mergeValues([previous, next], options, false, full);
-			else merged[key] = next;
-		}
-	}
-	return merged;
-}
-function mergeValues(values, options, validate, prefix) {
-	const actual = validate ? values.filter(isArrayOrPlainObject) : values;
-	return actual.length > 1 ? mergeObjects(actual, options, prefix) : actual[0] ?? {};
+function isSchematic(value) {
+	return typeof value === "object" && value !== null && SCHEMATIC_NAME in value && value[SCHEMATIC_NAME] === true;
 }
 function flattenObject(value, depth, smushed, prefix) {
 	if (depth >= MAX_DEPTH) return {};
@@ -669,7 +122,7 @@ function smush(value) {
 	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
 }
 var MAX_DEPTH = 100;
-function addPropertyType(to, key, values, required) {
+function addPropertyType(to, key, values, validators, required) {
 	if (to.keys.set.has(key)) {
 		const property = to.properties[key];
 		for (const type of values) if (!property.types.includes(type)) property.types.push(type);
@@ -678,10 +131,12 @@ function addPropertyType(to, key, values, required) {
 		to.keys.set.add(key);
 		to.properties[key] = {
 			required,
-			types: values
+			types: values,
+			validators: {}
 		};
 	}
 	if (!required && !to.properties[key].types.includes(TYPE_UNDEFINED)) to.properties[key].types.push(TYPE_UNDEFINED);
+	to.properties[key].validators = validators;
 }
 function getSchema(schema) {
 	const validated = {
@@ -706,7 +161,7 @@ function getTypes(value, validated, prefix) {
 			continue;
 		}
 		if (typeOfType === "function") {
-			propertyTypes.push(isConstructor$1(type) ? isInstance(type) : type);
+			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
 			continue;
 		}
 		if (typeOfType !== "object" || type === null) continue;
@@ -714,7 +169,7 @@ function getTypes(value, validated, prefix) {
 			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
 			continue;
 		}
-		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
+		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, type[PROPERTY_REQUIRED] !== false);
 		propertyTypes.push(TYPE_OBJECT);
 		getValidatedSchema(type, validated, prefix);
 	}
@@ -734,18 +189,30 @@ function getValidatedSchema(schema, validated, prefix) {
 		if (EXPRESSION_PROPERTY.test(key)) continue;
 		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ""))) continue;
 		let required = true;
-		if (typeof value === "object" && value !== null && PROPERTY_REQUIRED in value) required = typeof value[PROPERTY_REQUIRED] === "boolean" ? value[PROPERTY_REQUIRED] : true;
+		let validators = {};
+		const isObject = typeof value === "object" && value !== null;
+		if (isObject && PROPERTY_REQUIRED in value) required = typeof value[PROPERTY_REQUIRED] === "boolean" ? value[PROPERTY_REQUIRED] : true;
+		if (isObject && PROPERTY_VALIDATORS in value) validators = getValidators(value[PROPERTY_VALIDATORS]);
 		const prefixedKey = `${prefix}${key}`;
 		const types = getTypes(value, validated, prefixedKey);
-		if (types.length > 0) addPropertyType(validated, prefixedKey, types, required);
+		if (types.length > 0) addPropertyType(validated, prefixedKey, types, validators, required);
 	}
 	if (noPrefix) validated.keys.array.sort();
 	return validated;
 }
-function validateType(type, value) {
+function getValidators(original) {
+	const validators = {};
+	if (typeof original !== "object" || original === null) return validators;
+	for (const type of TYPE_ALL) {
+		const value = original[type];
+		validators[type] = (Array.isArray(value) ? value : [value]).filter((validator) => typeof validator === "function");
+	}
+	return validators;
+}
+function validateType(type, property, value) {
 	switch (true) {
 		case typeof type === "function": return type(value);
-		case typeof type === "string": return validators[type](value);
+		case typeof type === "string": return validators[type](value) && (property.validators[type]?.every((validator) => validator(value)) ?? true);
 		default: return type.is(value);
 	}
 }
@@ -764,12 +231,12 @@ function validateValue(validated, obj) {
 		if (value === void 0 && property.required && !property.types.includes(TYPE_UNDEFINED)) return false;
 		const typesLength = property.types.length;
 		if (typesLength === 1) {
-			if (!validateType(property.types[0], value)) return false;
+			if (!validateType(property.types[0], property, value)) return false;
 			continue;
 		}
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = property.types[typeIndex];
-			if (validateType(type, value)) {
+			if (validateType(type, property, value)) {
 				if (type !== "object") ignore.add(key);
 				continue outer;
 			}