@overlayed/cli 0.0.1 → 0.0.3

package/dist/lib-DalWKwNu.js

@@ -1,1041 +0,0 @@
-import { __commonJS } from "./chunk-RDQt0V5E.js";
-
-//#region ../../node_modules/.pnpm/typanion@3.14.0/node_modules/typanion/lib/index.js
-var require_lib = __commonJS({ "../../node_modules/.pnpm/typanion@3.14.0/node_modules/typanion/lib/index.js"(exports) {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	const simpleKeyRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-	function getPrintable(value) {
-		if (value === null) return `null`;
-		if (value === void 0) return `undefined`;
-		if (value === ``) return `an empty string`;
-		if (typeof value === "symbol") return `<${value.toString()}>`;
-		if (Array.isArray(value)) return `an array`;
-		return JSON.stringify(value);
-	}
-	function getPrintableArray(value, conjunction) {
-		if (value.length === 0) return `nothing`;
-		if (value.length === 1) return getPrintable(value[0]);
-		const rest = value.slice(0, -1);
-		const trailing = value[value.length - 1];
-		const separator = value.length > 2 ? `, ${conjunction} ` : ` ${conjunction} `;
-		return `${rest.map((value$1) => getPrintable(value$1)).join(`, `)}${separator}${getPrintable(trailing)}`;
-	}
-	function computeKey(state, key) {
-		var _a, _b, _c;
-		if (typeof key === `number`) return `${(_a = state === null || state === void 0 ? void 0 : state.p) !== null && _a !== void 0 ? _a : `.`}[${key}]`;
-		else if (simpleKeyRegExp.test(key)) return `${(_b = state === null || state === void 0 ? void 0 : state.p) !== null && _b !== void 0 ? _b : ``}.${key}`;
-		else return `${(_c = state === null || state === void 0 ? void 0 : state.p) !== null && _c !== void 0 ? _c : `.`}[${JSON.stringify(key)}]`;
-	}
-	function plural(n, singular, plural$1) {
-		return n === 1 ? singular : plural$1;
-	}
-	const colorStringRegExp = /^#[0-9a-f]{6}$/i;
-	const colorStringAlphaRegExp = /^#[0-9a-f]{6}([0-9a-f]{2})?$/i;
-	const base64RegExp = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
-	const uuid4RegExp = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}$/i;
-	const iso8601RegExp = /^(?:[1-9]\d{3}(-?)(?:(?:0[1-9]|1[0-2])\1(?:0[1-9]|1\d|2[0-8])|(?:0[13-9]|1[0-2])\1(?:29|30)|(?:0[13578]|1[02])(?:\1)31|00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[0-5]))|(?:[1-9]\d(?:0[48]|[2468][048]|[13579][26])|(?:[2468][048]|[13579][26])00)(?:(-?)02(?:\2)29|-?366))T(?:[01]\d|2[0-3])(:?)[0-5]\d(?:\3[0-5]\d)?(?:Z|[+-][01]\d(?:\3[0-5]\d)?)$/;
-	function pushError({ errors, p } = {}, message) {
-		errors === null || errors === void 0 || errors.push(`${p !== null && p !== void 0 ? p : `.`}: ${message}`);
-		return false;
-	}
-	function makeSetter(target, key) {
-		return (v) => {
-			target[key] = v;
-		};
-	}
-	function makeCoercionFn(target, key) {
-		return (v) => {
-			const previous = target[key];
-			target[key] = v;
-			return makeCoercionFn(target, key).bind(null, previous);
-		};
-	}
-	function makeLazyCoercionFn(fn$1, orig, generator) {
-		const commit = () => {
-			fn$1(generator());
-			return revert;
-		};
-		const revert = () => {
-			fn$1(orig);
-			return commit;
-		};
-		return commit;
-	}
-	/**
-	* Create a validator that always returns true and never refines the type.
-	*/
-	function isUnknown() {
-		return makeValidator({ test: (value, state) => {
-			return true;
-		} });
-	}
-	function isLiteral(expected) {
-		return makeValidator({ test: (value, state) => {
-			if (value !== expected) return pushError(state, `Expected ${getPrintable(expected)} (got ${getPrintable(value)})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that only returns true when the tested value is a string.
-	* Refines the type to `string`.
-	*/
-	function isString() {
-		return makeValidator({ test: (value, state) => {
-			if (typeof value !== `string`) return pushError(state, `Expected a string (got ${getPrintable(value)})`);
-			return true;
-		} });
-	}
-	function isEnum(enumSpec) {
-		const valuesArray = Array.isArray(enumSpec) ? enumSpec : Object.values(enumSpec);
-		const isAlphaNum = valuesArray.every((item) => typeof item === "string" || typeof item === "number");
-		const values = new Set(valuesArray);
-		if (values.size === 1) return isLiteral([...values][0]);
-		return makeValidator({ test: (value, state) => {
-			if (!values.has(value)) if (isAlphaNum) return pushError(state, `Expected one of ${getPrintableArray(valuesArray, `or`)} (got ${getPrintable(value)})`);
-			else return pushError(state, `Expected a valid enumeration value (got ${getPrintable(value)})`);
-			return true;
-		} });
-	}
-	const BOOLEAN_COERCIONS = new Map([
-		[`true`, true],
-		[`True`, true],
-		[`1`, true],
-		[1, true],
-		[`false`, false],
-		[`False`, false],
-		[`0`, false],
-		[0, false]
-	]);
-	/**
-	* Create a validator that only returns true when the tested value is a
-	* boolean. Refines the type to `boolean`.
-	*
-	* Supports coercion:
-	* - 'true' / 'True' / '1' / 1 will turn to `true`
-	* - 'false' / 'False' / '0' / 0 will turn to `false`
-	*/
-	function isBoolean() {
-		return makeValidator({ test: (value, state) => {
-			var _a;
-			if (typeof value !== `boolean`) {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-					if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-					const coercion = BOOLEAN_COERCIONS.get(value);
-					if (typeof coercion !== `undefined`) {
-						state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, coercion)]);
-						return true;
-					}
-				}
-				return pushError(state, `Expected a boolean (got ${getPrintable(value)})`);
-			}
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that only returns true when the tested value is a
-	* number (including floating numbers; use `cascade` and `isInteger` to
-	* restrict the range further). Refines the type to `number`.
-	*
-	* Supports coercion.
-	*/
-	function isNumber() {
-		return makeValidator({ test: (value, state) => {
-			var _a;
-			if (typeof value !== `number`) {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-					if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-					let coercion;
-					if (typeof value === `string`) {
-						let val;
-						try {
-							val = JSON.parse(value);
-						} catch (_b) {}
-						if (typeof val === `number`) if (JSON.stringify(val) === value) coercion = val;
-						else return pushError(state, `Received a number that can't be safely represented by the runtime (${value})`);
-					}
-					if (typeof coercion !== `undefined`) {
-						state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, coercion)]);
-						return true;
-					}
-				}
-				return pushError(state, `Expected a number (got ${getPrintable(value)})`);
-			}
-			return true;
-		} });
-	}
-	/**
-	* Important: This validator only makes sense when used in conjunction with
-	* coercion! It will always error when used without.
-	*
-	* Create a validator that only returns true when the tested value is a
-	* JSON representation of the expected type. Refines the type to the
-	* expected type, and casts the value into its inner value.
-	*/
-	function isPayload(spec) {
-		return makeValidator({ test: (value, state) => {
-			var _a;
-			if (typeof (state === null || state === void 0 ? void 0 : state.coercions) === `undefined`) return pushError(state, `The isPayload predicate can only be used with coercion enabled`);
-			if (typeof state.coercion === `undefined`) return pushError(state, `Unbound coercion result`);
-			if (typeof value !== `string`) return pushError(state, `Expected a string (got ${getPrintable(value)})`);
-			let inner;
-			try {
-				inner = JSON.parse(value);
-			} catch (_b) {
-				return pushError(state, `Expected a JSON string (got ${getPrintable(value)})`);
-			}
-			const wrapper = { value: inner };
-			if (!spec(inner, Object.assign(Object.assign({}, state), { coercion: makeCoercionFn(wrapper, `value`) }))) return false;
-			state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, wrapper.value)]);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that only returns true when the tested value is a
-	* valid date. Refines the type to `Date`.
-	*
-	* Supports coercion via one of the following formats:
-	* - ISO86001 strings
-	* - Unix timestamps
-	*/
-	function isDate() {
-		return makeValidator({ test: (value, state) => {
-			var _a;
-			if (!(value instanceof Date)) {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-					if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-					let coercion;
-					if (typeof value === `string` && iso8601RegExp.test(value)) coercion = new Date(value);
-					else {
-						let timestamp;
-						if (typeof value === `string`) {
-							let val;
-							try {
-								val = JSON.parse(value);
-							} catch (_b) {}
-							if (typeof val === `number`) timestamp = val;
-						} else if (typeof value === `number`) timestamp = value;
-						if (typeof timestamp !== `undefined`) if (Number.isSafeInteger(timestamp) || !Number.isSafeInteger(timestamp * 1e3)) coercion = /* @__PURE__ */ new Date(timestamp * 1e3);
-						else return pushError(state, `Received a timestamp that can't be safely represented by the runtime (${value})`);
-					}
-					if (typeof coercion !== `undefined`) {
-						state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, coercion)]);
-						return true;
-					}
-				}
-				return pushError(state, `Expected a date (got ${getPrintable(value)})`);
-			}
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that only returns true when the tested value is an
-	* array whose all values match the provided subspec. Refines the type to
-	* `Array<T>`, with `T` being the subspec inferred type.
-	*
-	* Supports coercion if the `delimiter` option is set, in which case strings
-	* will be split accordingly.
-	*/
-	function isArray(spec, { delimiter } = {}) {
-		return makeValidator({ test: (value, state) => {
-			var _a;
-			const originalValue = value;
-			if (typeof value === `string` && typeof delimiter !== `undefined`) {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-					if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-					value = value.split(delimiter);
-				}
-			}
-			if (!Array.isArray(value)) return pushError(state, `Expected an array (got ${getPrintable(value)})`);
-			let valid = true;
-			for (let t = 0, T = value.length; t < T; ++t) {
-				valid = spec(value[t], Object.assign(Object.assign({}, state), {
-					p: computeKey(state, t),
-					coercion: makeCoercionFn(value, t)
-				})) && valid;
-				if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) break;
-			}
-			if (value !== originalValue) state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, value)]);
-			return valid;
-		} });
-	}
-	/**
-	* Create a validator that only returns true when the tested value is an
-	* set whose all values match the provided subspec. Refines the type to
-	* `Set<T>`, with `T` being the subspec inferred type.
-	*
-	* Supports coercion from arrays (or anything that can be coerced into an
-	* array).
-	*/
-	function isSet(spec, { delimiter } = {}) {
-		const isArrayValidator = isArray(spec, { delimiter });
-		return makeValidator({ test: (value, state) => {
-			var _a, _b;
-			if (Object.getPrototypeOf(value).toString() === `[object Set]`) if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-				const originalValues = [...value];
-				const coercedValues = [...value];
-				if (!isArrayValidator(coercedValues, Object.assign(Object.assign({}, state), { coercion: void 0 }))) return false;
-				const updateValue = () => coercedValues.some((val, t) => val !== originalValues[t]) ? new Set(coercedValues) : value;
-				state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, makeLazyCoercionFn(state.coercion, value, updateValue)]);
-				return true;
-			} else {
-				let valid = true;
-				for (const subValue of value) {
-					valid = spec(subValue, Object.assign({}, state)) && valid;
-					if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) break;
-				}
-				return valid;
-			}
-			if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-				const store = { value };
-				if (!isArrayValidator(value, Object.assign(Object.assign({}, state), { coercion: makeCoercionFn(store, `value`) }))) return false;
-				state.coercions.push([(_b = state.p) !== null && _b !== void 0 ? _b : `.`, makeLazyCoercionFn(state.coercion, value, () => new Set(store.value))]);
-				return true;
-			}
-			return pushError(state, `Expected a set (got ${getPrintable(value)})`);
-		} });
-	}
-	/**
-	* Create a validator that only returns true when the tested value is an
-	* map whose all values match the provided subspecs. Refines the type to
-	* `Map<U, V>`, with `U` being the key subspec inferred type and `V` being
-	* the value subspec inferred type.
-	*
-	* Supports coercion from array of tuples (or anything that can be coerced into
-	* an array of tuples).
-	*/
-	function isMap(keySpec, valueSpec) {
-		const isArrayValidator = isArray(isTuple([keySpec, valueSpec]));
-		const isRecordValidator = isRecord(valueSpec, { keys: keySpec });
-		return makeValidator({ test: (value, state) => {
-			var _a, _b, _c;
-			if (Object.getPrototypeOf(value).toString() === `[object Map]`) if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-				const originalValues = [...value];
-				const coercedValues = [...value];
-				if (!isArrayValidator(coercedValues, Object.assign(Object.assign({}, state), { coercion: void 0 }))) return false;
-				const updateValue = () => coercedValues.some((val, t) => val[0] !== originalValues[t][0] || val[1] !== originalValues[t][1]) ? new Map(coercedValues) : value;
-				state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, makeLazyCoercionFn(state.coercion, value, updateValue)]);
-				return true;
-			} else {
-				let valid = true;
-				for (const [key, subValue] of value) {
-					valid = keySpec(key, Object.assign({}, state)) && valid;
-					if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) break;
-					valid = valueSpec(subValue, Object.assign(Object.assign({}, state), { p: computeKey(state, key) })) && valid;
-					if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) break;
-				}
-				return valid;
-			}
-			if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-				const store = { value };
-				if (Array.isArray(value)) {
-					if (!isArrayValidator(value, Object.assign(Object.assign({}, state), { coercion: void 0 }))) return false;
-					state.coercions.push([(_b = state.p) !== null && _b !== void 0 ? _b : `.`, makeLazyCoercionFn(state.coercion, value, () => new Map(store.value))]);
-					return true;
-				} else {
-					if (!isRecordValidator(value, Object.assign(Object.assign({}, state), { coercion: makeCoercionFn(store, `value`) }))) return false;
-					state.coercions.push([(_c = state.p) !== null && _c !== void 0 ? _c : `.`, makeLazyCoercionFn(state.coercion, value, () => new Map(Object.entries(store.value)))]);
-					return true;
-				}
-			}
-			return pushError(state, `Expected a map (got ${getPrintable(value)})`);
-		} });
-	}
-	/**
-	* Create a validator that only returns true when the tested value is a
-	* tuple whose each value matches the corresponding subspec. Refines the type
-	* into a tuple whose each item has the type inferred by the corresponding
-	* tuple.
-	*
-	* Supports coercion if the `delimiter` option is set, in which case strings
-	* will be split accordingly.
-	*/
-	function isTuple(spec, { delimiter } = {}) {
-		const lengthValidator = hasExactLength(spec.length);
-		return makeValidator({ test: (value, state) => {
-			var _a;
-			if (typeof value === `string` && typeof delimiter !== `undefined`) {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-					if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-					value = value.split(delimiter);
-					state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, value)]);
-				}
-			}
-			if (!Array.isArray(value)) return pushError(state, `Expected a tuple (got ${getPrintable(value)})`);
-			let valid = lengthValidator(value, Object.assign({}, state));
-			for (let t = 0, T = value.length; t < T && t < spec.length; ++t) {
-				valid = spec[t](value[t], Object.assign(Object.assign({}, state), {
-					p: computeKey(state, t),
-					coercion: makeCoercionFn(value, t)
-				})) && valid;
-				if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) break;
-			}
-			return valid;
-		} });
-	}
-	/**
-	* Create a validator that only returns true when the tested value is an
-	* object with any amount of properties that must all match the provided
-	* subspec. Refines the type to `Record<string, T>`, with `T` being the
-	* subspec inferred type.
-	*
-	* Keys can be optionally validated as well by using the `keys` optional
-	* subspec parameter.
-	*/
-	function isRecord(spec, { keys: keySpec = null } = {}) {
-		const isArrayValidator = isArray(isTuple([keySpec !== null && keySpec !== void 0 ? keySpec : isString(), spec]));
-		return makeValidator({ test: (value, state) => {
-			var _a;
-			if (Array.isArray(value)) {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-					if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-					if (!isArrayValidator(value, Object.assign(Object.assign({}, state), { coercion: void 0 }))) return false;
-					value = Object.fromEntries(value);
-					state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, value)]);
-					return true;
-				}
-			}
-			if (typeof value !== `object` || value === null) return pushError(state, `Expected an object (got ${getPrintable(value)})`);
-			const keys = Object.keys(value);
-			let valid = true;
-			for (let t = 0, T = keys.length; t < T && (valid || (state === null || state === void 0 ? void 0 : state.errors) != null); ++t) {
-				const key = keys[t];
-				const sub = value[key];
-				if (key === `__proto__` || key === `constructor`) {
-					valid = pushError(Object.assign(Object.assign({}, state), { p: computeKey(state, key) }), `Unsafe property name`);
-					continue;
-				}
-				if (keySpec !== null && !keySpec(key, state)) {
-					valid = false;
-					continue;
-				}
-				if (!spec(sub, Object.assign(Object.assign({}, state), {
-					p: computeKey(state, key),
-					coercion: makeCoercionFn(value, key)
-				}))) {
-					valid = false;
-					continue;
-				}
-			}
-			return valid;
-		} });
-	}
-	/**
-	* @deprecated Replace `isDict` by `isRecord`
-	*/
-	function isDict(spec, opts = {}) {
-		return isRecord(spec, opts);
-	}
-	/**
-	* Create a validator that only returns true when the tested value is an
-	* object whose all properties match their corresponding subspec. Refines
-	* the type into an object whose each property has the type inferred by the
-	* corresponding subspec.
-	*
-	* Unlike `t.isPartial`, `t.isObject` doesn't allow extraneous properties by
-	* default. This behaviour can be altered by using the `extra` optional
-	* subspec parameter, which will be called to validate an object only
-	* containing the extraneous properties.
-	*
-	* Calling `t.isObject(..., {extra: t.isRecord(t.isUnknown())})` is
-	* essentially the same as calling `t.isPartial(...)`.
-	*/
-	function isObject(props, { extra: extraSpec = null } = {}) {
-		const specKeys = Object.keys(props);
-		const validator = makeValidator({ test: (value, state) => {
-			if (typeof value !== `object` || value === null) return pushError(state, `Expected an object (got ${getPrintable(value)})`);
-			const keys = new Set([...specKeys, ...Object.keys(value)]);
-			const extra = {};
-			let valid = true;
-			for (const key of keys) {
-				if (key === `constructor` || key === `__proto__`) valid = pushError(Object.assign(Object.assign({}, state), { p: computeKey(state, key) }), `Unsafe property name`);
-				else {
-					const spec = Object.prototype.hasOwnProperty.call(props, key) ? props[key] : void 0;
-					const sub = Object.prototype.hasOwnProperty.call(value, key) ? value[key] : void 0;
-					if (typeof spec !== `undefined`) valid = spec(sub, Object.assign(Object.assign({}, state), {
-						p: computeKey(state, key),
-						coercion: makeCoercionFn(value, key)
-					})) && valid;
-					else if (extraSpec === null) valid = pushError(Object.assign(Object.assign({}, state), { p: computeKey(state, key) }), `Extraneous property (got ${getPrintable(sub)})`);
-					else Object.defineProperty(extra, key, {
-						enumerable: true,
-						get: () => sub,
-						set: makeSetter(value, key)
-					});
-				}
-				if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) break;
-			}
-			if (extraSpec !== null && (valid || (state === null || state === void 0 ? void 0 : state.errors) != null)) valid = extraSpec(extra, state) && valid;
-			return valid;
-		} });
-		return Object.assign(validator, { properties: props });
-	}
-	/**
-	* Create a validator that only returns true when the tested value is an
-	* object whose all properties match their corresponding subspec. Refines
-	* the type into an object whose each property has the type inferred by the
-	* corresponding subspec.
-	*
-	* Unlike `t.isObject`, `t.isPartial` allows extraneous properties. The
-	* resulting type will reflect this behaviour by including an index
-	* signature (each extraneous property being typed `unknown`).
-	*
-	* Calling `t.isPartial(...)` is essentially the same as calling
-	* `t.isObject(..., {extra: t.isRecord(t.isUnknown())})`.
-	*/
-	function isPartial(props) {
-		return isObject(props, { extra: isRecord(isUnknown()) });
-	}
-	/**
-	* Create a validator that only returns true when the tested value is an
-	* object whose prototype is derived from the given class. Refines the type
-	* into a class instance.
-	*/
-	const isInstanceOf = (constructor) => makeValidator({ test: (value, state) => {
-		if (!(value instanceof constructor)) return pushError(state, `Expected an instance of ${constructor.name} (got ${getPrintable(value)})`);
-		return true;
-	} });
-	/**
-	* Create a validator that only returns true when the tested value is an
-	* object matching any of the provided subspecs. If the optional `exclusive`
-	* parameter is set to `true`, the behaviour changes so that the validator
-	* only returns true when exactly one subspec matches.
-	*/
-	const isOneOf = (specs, { exclusive = false } = {}) => makeValidator({ test: (value, state) => {
-		var _a, _b, _c;
-		const matches = [];
-		const errorBuffer = typeof (state === null || state === void 0 ? void 0 : state.errors) !== `undefined` ? [] : void 0;
-		for (let t = 0, T = specs.length; t < T; ++t) {
-			const subErrors = typeof (state === null || state === void 0 ? void 0 : state.errors) !== `undefined` ? [] : void 0;
-			const subCoercions = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? [] : void 0;
-			if (specs[t](value, Object.assign(Object.assign({}, state), {
-				errors: subErrors,
-				coercions: subCoercions,
-				p: `${(_a = state === null || state === void 0 ? void 0 : state.p) !== null && _a !== void 0 ? _a : `.`}#${t + 1}`
-			}))) {
-				matches.push([`#${t + 1}`, subCoercions]);
-				if (!exclusive) break;
-			} else errorBuffer === null || errorBuffer === void 0 || errorBuffer.push(subErrors[0]);
-		}
-		if (matches.length === 1) {
-			const [, subCoercions] = matches[0];
-			if (typeof subCoercions !== `undefined`) (_b = state === null || state === void 0 ? void 0 : state.coercions) === null || _b === void 0 || _b.push(...subCoercions);
-			return true;
-		}
-		if (matches.length > 1) pushError(state, `Expected to match exactly a single predicate (matched ${matches.join(`, `)})`);
-		else (_c = state === null || state === void 0 ? void 0 : state.errors) === null || _c === void 0 || _c.push(...errorBuffer);
-		return false;
-	} });
-	function makeTrait(value) {
-		return () => {
-			return value;
-		};
-	}
-	function makeValidator({ test }) {
-		return makeTrait(test)();
-	}
-	var TypeAssertionError = class extends Error {
-		constructor({ errors } = {}) {
-			let errorMessage = `Type mismatch`;
-			if (errors && errors.length > 0) {
-				errorMessage += `\n`;
-				for (const error of errors) errorMessage += `\n- ${error}`;
-			}
-			super(errorMessage);
-		}
-	};
-	/**
-	* Check that the specified value matches the given validator, and throws an
-	* exception if it doesn't. Refine the type if it passes.
-	*/
-	function assert(val, validator) {
-		if (!validator(val)) throw new TypeAssertionError();
-	}
-	/**
-	* Check that the specified value matches the given validator, and throws an
-	* exception if it doesn't. Refine the type if it passes.
-	*
-	* Thrown exceptions include details about what exactly looks invalid in the
-	* tested value.
-	*/
-	function assertWithErrors(val, validator) {
-		const errors = [];
-		if (!validator(val, { errors })) throw new TypeAssertionError({ errors });
-	}
-	/**
-	* Compile-time only. Refine the type as if the validator was matching the
-	* tested value, but doesn't actually run it. Similar to the classic `as`
-	* operator in TypeScript.
-	*/
-	function softAssert(val, validator) {}
-	function as(value, validator, { coerce = false, errors: storeErrors, throw: throws } = {}) {
-		const errors = storeErrors ? [] : void 0;
-		if (!coerce) if (validator(value, { errors })) return throws ? value : {
-			value,
-			errors: void 0
-		};
-		else if (!throws) return {
-			value: void 0,
-			errors: errors !== null && errors !== void 0 ? errors : true
-		};
-		else throw new TypeAssertionError({ errors });
-		const state = { value };
-		const coercion = makeCoercionFn(state, `value`);
-		const coercions = [];
-		if (!validator(value, {
-			errors,
-			coercion,
-			coercions
-		})) if (!throws) return {
-			value: void 0,
-			errors: errors !== null && errors !== void 0 ? errors : true
-		};
-		else throw new TypeAssertionError({ errors });
-		for (const [, apply] of coercions) apply();
-		if (throws) return state.value;
-		else return {
-			value: state.value,
-			errors: void 0
-		};
-	}
-	/**
-	* Create and return a new function that apply the given validators to each
-	* corresponding argument passed to the function and throws an exception in
-	* case of a mismatch.
-	*/
-	function fn(validators, fn$1) {
-		const isValidArgList = isTuple(validators);
-		return (...args) => {
-			const check = isValidArgList(args);
-			if (!check) throw new TypeAssertionError();
-			return fn$1(...args);
-		};
-	}
-	/**
-	* Create a validator that checks that the tested array or string has at least
-	* the specified length.
-	*/
-	function hasMinLength(length) {
-		return makeValidator({ test: (value, state) => {
-			if (!(value.length >= length)) return pushError(state, `Expected to have a length of at least ${length} elements (got ${value.length})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested array or string has at most
-	* the specified length.
-	*/
-	function hasMaxLength(length) {
-		return makeValidator({ test: (value, state) => {
-			if (!(value.length <= length)) return pushError(state, `Expected to have a length of at most ${length} elements (got ${value.length})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested array or string has exactly
-	* the specified length.
-	*/
-	function hasExactLength(length) {
-		return makeValidator({ test: (value, state) => {
-			if (!(value.length === length)) return pushError(state, `Expected to have a length of exactly ${length} elements (got ${value.length})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested array only contains unique
-	* elements. The optional `map` parameter lets you define a transform to
-	* apply before making the check (the result of this transform will be
-	* discarded afterwards).
-	*/
-	function hasUniqueItems({ map } = {}) {
-		return makeValidator({ test: (value, state) => {
-			const set = /* @__PURE__ */ new Set();
-			const dup = /* @__PURE__ */ new Set();
-			for (let t = 0, T = value.length; t < T; ++t) {
-				const sub = value[t];
-				const key = typeof map !== `undefined` ? map(sub) : sub;
-				if (set.has(key)) {
-					if (dup.has(key)) continue;
-					pushError(state, `Expected to contain unique elements; got a duplicate with ${getPrintable(value)}`);
-					dup.add(key);
-				} else set.add(key);
-			}
-			return dup.size === 0;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested number is strictly less than 0.
-	*/
-	function isNegative() {
-		return makeValidator({ test: (value, state) => {
-			if (!(value <= 0)) return pushError(state, `Expected to be negative (got ${value})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested number is equal or greater
-	* than 0.
-	*/
-	function isPositive() {
-		return makeValidator({ test: (value, state) => {
-			if (!(value >= 0)) return pushError(state, `Expected to be positive (got ${value})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested number is equal or greater
-	* than the specified reference.
-	*/
-	function isAtLeast(n) {
-		return makeValidator({ test: (value, state) => {
-			if (!(value >= n)) return pushError(state, `Expected to be at least ${n} (got ${value})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested number is equal or smaller
-	* than the specified reference.
-	*/
-	function isAtMost(n) {
-		return makeValidator({ test: (value, state) => {
-			if (!(value <= n)) return pushError(state, `Expected to be at most ${n} (got ${value})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested number is between the
-	* specified references (including the upper boundary).
-	*/
-	function isInInclusiveRange(a, b) {
-		return makeValidator({ test: (value, state) => {
-			if (!(value >= a && value <= b)) return pushError(state, `Expected to be in the [${a}; ${b}] range (got ${value})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested number is between the
-	* specified references (excluding the upper boundary).
-	*/
-	function isInExclusiveRange(a, b) {
-		return makeValidator({ test: (value, state) => {
-			if (!(value >= a && value < b)) return pushError(state, `Expected to be in the [${a}; ${b}[ range (got ${value})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested number is an integer.
-	*
-	* By default Typanion will also check that it's a *safe* integer. For example,
-	* 2^53 wouldn't be a safe integer because 2^53+1 would be rounded to 2^53,
-	* which could put your applications at risk when used in loops.
-	*/
-	function isInteger({ unsafe = false } = {}) {
-		return makeValidator({ test: (value, state) => {
-			if (value !== Math.round(value)) return pushError(state, `Expected to be an integer (got ${value})`);
-			if (!unsafe && !Number.isSafeInteger(value)) return pushError(state, `Expected to be a safe integer (got ${value})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested string matches the given
-	* regular expression.
-	*/
-	function matchesRegExp(regExp) {
-		return makeValidator({ test: (value, state) => {
-			if (!regExp.test(value)) return pushError(state, `Expected to match the pattern ${regExp.toString()} (got ${getPrintable(value)})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested string only contain lowercase
-	* characters.
-	*/
-	function isLowerCase() {
-		return makeValidator({ test: (value, state) => {
-			if (value !== value.toLowerCase()) return pushError(state, `Expected to be all-lowercase (got ${value})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested string only contain uppercase
-	* characters.
-	*/
-	function isUpperCase() {
-		return makeValidator({ test: (value, state) => {
-			if (value !== value.toUpperCase()) return pushError(state, `Expected to be all-uppercase (got ${value})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested string is a valid UUID v4.
-	*/
-	function isUUID4() {
-		return makeValidator({ test: (value, state) => {
-			if (!uuid4RegExp.test(value)) return pushError(state, `Expected to be a valid UUID v4 (got ${getPrintable(value)})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested string is a valid ISO8601
-	* date.
-	*/
-	function isISO8601() {
-		return makeValidator({ test: (value, state) => {
-			if (!iso8601RegExp.test(value)) return pushError(state, `Expected to be a valid ISO 8601 date string (got ${getPrintable(value)})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested string is a valid hexadecimal
-	* color. Setting the optional `alpha` parameter to `true` allows an additional
-	* transparency channel to be included.
-	*/
-	function isHexColor({ alpha = false }) {
-		return makeValidator({ test: (value, state) => {
-			const res = alpha ? colorStringRegExp.test(value) : colorStringAlphaRegExp.test(value);
-			if (!res) return pushError(state, `Expected to be a valid hexadecimal color string (got ${getPrintable(value)})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested string is valid base64.
-	*/
-	function isBase64() {
-		return makeValidator({ test: (value, state) => {
-			if (!base64RegExp.test(value)) return pushError(state, `Expected to be a valid base 64 string (got ${getPrintable(value)})`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested string is valid JSON. A
-	* optional spec can be passed as parameter, in which case the data will be
-	* deserialized and validated against the spec (coercion will be disabled
-	* for this check, and even if successful the returned value will still be
-	* the original string).
-	*/
-	function isJSON(spec = isUnknown()) {
-		return makeValidator({ test: (value, state) => {
-			let data;
-			try {
-				data = JSON.parse(value);
-			} catch (_a) {
-				return pushError(state, `Expected to be a valid JSON string (got ${getPrintable(value)})`);
-			}
-			return spec(data, state);
-		} });
-	}
-	function cascade(spec, ...followups) {
-		const resolvedFollowups = Array.isArray(followups[0]) ? followups[0] : followups;
-		return makeValidator({ test: (value, state) => {
-			var _a, _b;
-			const context = { value };
-			const subCoercion = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? makeCoercionFn(context, `value`) : void 0;
-			const subCoercions = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? [] : void 0;
-			if (!spec(value, Object.assign(Object.assign({}, state), {
-				coercion: subCoercion,
-				coercions: subCoercions
-			}))) return false;
-			const reverts = [];
-			if (typeof subCoercions !== `undefined`) for (const [, coercion] of subCoercions) reverts.push(coercion());
-			try {
-				if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
-					if (context.value !== value) {
-						if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`) return pushError(state, `Unbound coercion result`);
-						state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, context.value)]);
-					}
-					(_b = state === null || state === void 0 ? void 0 : state.coercions) === null || _b === void 0 || _b.push(...subCoercions);
-				}
-				return resolvedFollowups.every((spec$1) => {
-					return spec$1(context.value, state);
-				});
-			} finally {
-				for (const revert of reverts) revert();
-			}
-		} });
-	}
-	function applyCascade(spec, ...followups) {
-		const resolvedFollowups = Array.isArray(followups[0]) ? followups[0] : followups;
-		return cascade(spec, resolvedFollowups);
-	}
-	/**
-	* Wraps the given spec to also allow `undefined`.
-	*/
-	function isOptional(spec) {
-		return makeValidator({ test: (value, state) => {
-			if (typeof value === `undefined`) return true;
-			return spec(value, state);
-		} });
-	}
-	/**
-	* Wraps the given spec to also allow `null`.
-	*/
-	function isNullable(spec) {
-		return makeValidator({ test: (value, state) => {
-			if (value === null) return true;
-			return spec(value, state);
-		} });
-	}
-	const checks = {
-		missing: (keys, key) => keys.has(key),
-		undefined: (keys, key, value) => keys.has(key) && typeof value[key] !== `undefined`,
-		nil: (keys, key, value) => keys.has(key) && value[key] != null,
-		falsy: (keys, key, value) => keys.has(key) && !!value[key]
-	};
-	/**
-	* Create a validator that checks that the tested object contains the specified
-	* keys.
-	*/
-	function hasRequiredKeys(requiredKeys, options) {
-		var _a;
-		const requiredSet = new Set(requiredKeys);
-		const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
-		return makeValidator({ test: (value, state) => {
-			const keys = new Set(Object.keys(value));
-			const problems = [];
-			for (const key of requiredSet) if (!check(keys, key, value)) problems.push(key);
-			if (problems.length > 0) return pushError(state, `Missing required ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, `and`)}`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested object contains at least one
-	* of the specified keys.
-	*/
-	function hasAtLeastOneKey(requiredKeys, options) {
-		var _a;
-		const requiredSet = new Set(requiredKeys);
-		const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
-		return makeValidator({ test: (value, state) => {
-			const keys = Object.keys(value);
-			const valid = keys.some((key) => check(requiredSet, key, value));
-			if (!valid) return pushError(state, `Missing at least one property from ${getPrintableArray(Array.from(requiredSet), `or`)}`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested object contains none of the
-	* specified keys.
-	*/
-	function hasForbiddenKeys(forbiddenKeys, options) {
-		var _a;
-		const forbiddenSet = new Set(forbiddenKeys);
-		const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
-		return makeValidator({ test: (value, state) => {
-			const keys = new Set(Object.keys(value));
-			const problems = [];
-			for (const key of forbiddenSet) if (check(keys, key, value)) problems.push(key);
-			if (problems.length > 0) return pushError(state, `Forbidden ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, `and`)}`);
-			return true;
-		} });
-	}
-	/**
-	* Create a validator that checks that the tested object contains at most one
-	* of the specified keys.
-	*/
-	function hasMutuallyExclusiveKeys(exclusiveKeys, options) {
-		var _a;
-		const exclusiveSet = new Set(exclusiveKeys);
-		const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
-		return makeValidator({ test: (value, state) => {
-			const keys = new Set(Object.keys(value));
-			const used = [];
-			for (const key of exclusiveSet) if (check(keys, key, value)) used.push(key);
-			if (used.length > 1) return pushError(state, `Mutually exclusive properties ${getPrintableArray(used, `and`)}`);
-			return true;
-		} });
-	}
-	(function(KeyRelationship) {
-		KeyRelationship["Forbids"] = "Forbids";
-		KeyRelationship["Requires"] = "Requires";
-	})(exports.KeyRelationship || (exports.KeyRelationship = {}));
-	const keyRelationships = {
-		[exports.KeyRelationship.Forbids]: {
-			expect: false,
-			message: `forbids using`
-		},
-		[exports.KeyRelationship.Requires]: {
-			expect: true,
-			message: `requires using`
-		}
-	};
-	/**
-	* Create a validator that checks that, when the specified subject property is
-	* set, the relationship is satisfied.
-	*/
-	function hasKeyRelationship(subject, relationship, others, options) {
-		var _a, _b;
-		const skipped = new Set((_a = options === null || options === void 0 ? void 0 : options.ignore) !== null && _a !== void 0 ? _a : []);
-		const check = checks[(_b = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _b !== void 0 ? _b : "missing"];
-		const otherSet = new Set(others);
-		const spec = keyRelationships[relationship];
-		const conjunction = relationship === exports.KeyRelationship.Forbids ? `or` : `and`;
-		return makeValidator({ test: (value, state) => {
-			const keys = new Set(Object.keys(value));
-			if (!check(keys, subject, value) || skipped.has(value[subject])) return true;
-			const problems = [];
-			for (const key of otherSet) if ((check(keys, key, value) && !skipped.has(value[key])) !== spec.expect) problems.push(key);
-			if (problems.length >= 1) return pushError(state, `Property "${subject}" ${spec.message} ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, conjunction)}`);
-			return true;
-		} });
-	}
-	exports.TypeAssertionError = TypeAssertionError;
-	exports.applyCascade = applyCascade;
-	exports.as = as;
-	exports.assert = assert;
-	exports.assertWithErrors = assertWithErrors;
-	exports.cascade = cascade;
-	exports.fn = fn;
-	exports.hasAtLeastOneKey = hasAtLeastOneKey;
-	exports.hasExactLength = hasExactLength;
-	exports.hasForbiddenKeys = hasForbiddenKeys;
-	exports.hasKeyRelationship = hasKeyRelationship;
-	exports.hasMaxLength = hasMaxLength;
-	exports.hasMinLength = hasMinLength;
-	exports.hasMutuallyExclusiveKeys = hasMutuallyExclusiveKeys;
-	exports.hasRequiredKeys = hasRequiredKeys;
-	exports.hasUniqueItems = hasUniqueItems;
-	exports.isArray = isArray;
-	exports.isAtLeast = isAtLeast;
-	exports.isAtMost = isAtMost;
-	exports.isBase64 = isBase64;
-	exports.isBoolean = isBoolean;
-	exports.isDate = isDate;
-	exports.isDict = isDict;
-	exports.isEnum = isEnum;
-	exports.isHexColor = isHexColor;
-	exports.isISO8601 = isISO8601;
-	exports.isInExclusiveRange = isInExclusiveRange;
-	exports.isInInclusiveRange = isInInclusiveRange;
-	exports.isInstanceOf = isInstanceOf;
-	exports.isInteger = isInteger;
-	exports.isJSON = isJSON;
-	exports.isLiteral = isLiteral;
-	exports.isLowerCase = isLowerCase;
-	exports.isMap = isMap;
-	exports.isNegative = isNegative;
-	exports.isNullable = isNullable;
-	exports.isNumber = isNumber;
-	exports.isObject = isObject;
-	exports.isOneOf = isOneOf;
-	exports.isOptional = isOptional;
-	exports.isPartial = isPartial;
-	exports.isPayload = isPayload;
-	exports.isPositive = isPositive;
-	exports.isRecord = isRecord;
-	exports.isSet = isSet;
-	exports.isString = isString;
-	exports.isTuple = isTuple;
-	exports.isUUID4 = isUUID4;
-	exports.isUnknown = isUnknown;
-	exports.isUpperCase = isUpperCase;
-	exports.makeTrait = makeTrait;
-	exports.makeValidator = makeValidator;
-	exports.matchesRegExp = matchesRegExp;
-	exports.softAssert = softAssert;
-} });
-
-//#endregion
-export default require_lib();