@alint-js/plugin-simplicity 0.0.27 → 0.0.29

package/dist/S-CK_sYI4B.mjs

@@ -0,0 +1,3796 @@
+//#region ../../node_modules/.pnpm/sury@11.0.0-alpha.10/node_modules/sury/src/S.mjs
+var stringTag = "string";
+var numberTag = "number";
+var bigintTag = "bigint";
+var booleanTag = "boolean";
+var symbolTag = "symbol";
+var nullTag = "null";
+var undefinedTag = "undefined";
+var nanTag = "nan";
+var functionTag = "function";
+var instanceTag = "instance";
+var arrayTag = "array";
+var objectTag = "object";
+var unionTag = "union";
+var neverTag = "never";
+var unknownTag = "unknown";
+var refTag = "ref";
+var tagFlagUnknown = 1;
+var tagFlagString = 2;
+var tagFlagNumber = 4;
+var tagFlagBoolean = 8;
+var tagFlagUndefined = 16;
+var tagFlagNull = 32;
+var tagFlagObject = 64;
+var tagFlagArray = 128;
+var tagFlagUnion = 256;
+var tagFlagRef = 512;
+var tagFlagBigint = 1024;
+var tagFlagNaN = 2048;
+var tagFlagFunction = 4096;
+var tagFlagInstance = 8192;
+var tagFlagSymbol = 16384;
+var tagFlags = {
+	[unknownTag]: 1,
+	[stringTag]: 2,
+	[numberTag]: 4,
+	[booleanTag]: 8,
+	[undefinedTag]: 16,
+	[nullTag]: 32,
+	[objectTag]: 64,
+	[arrayTag]: 128,
+	[unionTag]: 256,
+	[refTag]: 512,
+	[bigintTag]: 1024,
+	[nanTag]: 2048,
+	[functionTag]: 4096,
+	[instanceTag]: 8192,
+	[neverTag]: 32768,
+	[symbolTag]: 16384
+};
+var flagNone = 0;
+var flagAsync = 1;
+var flagDisableNanNumberValidation = 2;
+var flagUnsafeHas = (acc, flag) => {
+	return (acc & flag) !== 0;
+};
+var valFlagNone = 0;
+var valFlagAsync = 1;
+var vendor = "sury";
+var s = /* @__PURE__ */ Symbol(vendor);
+var itemSymbol = /* @__PURE__ */ Symbol(vendor + ":item");
+var shouldPrependPathKey = "p";
+var immutableEmptyArray = [];
+var immutableEmptyObject = /* @__PURE__ */ Object.create(null);
+var isSchemaObject = (obj) => {
+	return !!obj["~standard"];
+};
+var constField = "const";
+var isLiteral = (schema) => {
+	return constField in schema;
+};
+var isOptional = (schema) => {
+	return schema.type === undefinedTag || schema.type === unionTag && undefinedTag in schema.has;
+};
+var stringify = (unknown2) => {
+	const tagFlag = tagFlags[typeof unknown2];
+	if (flagUnsafeHas(tagFlag, tagFlagUndefined)) return undefinedTag;
+	else if (flagUnsafeHas(tagFlag, tagFlagObject)) if (unknown2 === null) return nullTag;
+	else if (Array.isArray(unknown2)) return `[${unknown2.map(stringify).join(", ")}]`;
+	else if (unknown2.constructor === Object) {
+		const dict2 = unknown2;
+		return `{ ${Object.keys(dict2).map((key) => `${key}: ${stringify(dict2[key])}; `).join("")}}`;
+	} else return Object.prototype.toString.call(unknown2);
+	else if (flagUnsafeHas(tagFlag, tagFlagString)) return `"${unknown2}"`;
+	else if (flagUnsafeHas(tagFlag, tagFlagBigint)) return `${unknown2}n`;
+	else if (flagUnsafeHas(tagFlag, tagFlagFunction)) return `Function`;
+	else return unknown2.toString();
+};
+var toExpression = (schema) => {
+	if (schema.name !== void 0) return schema.name;
+	else if (schema.const !== void 0) return stringify(schema.const);
+	else if (schema.anyOf !== void 0) return schema.anyOf.map(toExpression).join(" | ");
+	else if (schema.format === "compactColumns") {
+		const to = schema.to;
+		if (to !== void 0) {
+			const props = to.properties;
+			if (props !== void 0) return `[${Object.keys(props).map((key) => {
+				const propSchema = props[key];
+				return `${toExpression(propSchema)}[]`;
+			}).join(", ")}]`;
+			else return "unknown[][]";
+		} else {
+			const additionalItems = schema.additionalItems;
+			if (additionalItems !== void 0 && typeof additionalItems === "object") return `${toExpression(additionalItems)}[]`;
+			else return "unknown[][]";
+		}
+	} else if (schema.format !== void 0) return schema.format;
+	else if (schema.type === objectTag) {
+		const properties = schema.properties;
+		const locations = Object.keys(properties);
+		if (locations.length === 0) if (typeof schema.additionalItems === objectTag) {
+			const additionalItems = schema.additionalItems;
+			return `{ [key: string]: ${toExpression(additionalItems)}; }`;
+		} else return `{}`;
+		else return `{ ${locations.map((location) => {
+			return `${location}: ${toExpression(properties[location])};`;
+		}).join(" ")} }`;
+	} else if (schema.type === nanTag) return "NaN";
+	else if (schema.type === arrayTag) {
+		const items = schema.items;
+		if (typeof schema.additionalItems === objectTag) {
+			const additionalItems = schema.additionalItems;
+			const itemName = toExpression(additionalItems);
+			return (additionalItems.type === unionTag ? `(${itemName})` : itemName) + "[]";
+		} else return `[${items.map((schema2) => toExpression(schema2)).join(", ")}]`;
+	} else if (schema.type === instanceTag) return schema.class.name;
+	else return schema.type;
+};
+function Schema() {}
+var schemaPrototype = /* @__PURE__ */ Object.create(null);
+Object.defineProperty(schemaPrototype, "with", { get() {
+	return (fn, ...args) => fn(this, ...args);
+} });
+Schema.prototype = schemaPrototype;
+var seq = 1;
+var exnId = {};
+var __setExnId = (id) => {
+	exnId = id;
+};
+var SuryError = class extends Error {
+	constructor(params) {
+		super();
+		Object.assign(this, params);
+	}
+	get message() {
+		return formatErrorMessage(this);
+	}
+	get _1() {
+		return this;
+	}
+	get RE_EXN_ID() {
+		return exnId;
+	}
+};
+Object.defineProperty(SuryError.prototype, "name", { value: "SuryError" });
+Object.defineProperty(SuryError.prototype, "s", { value: s });
+var getOrRethrow = (exn) => {
+	if (exn && exn.s === s) return exn;
+	else throw exn;
+};
+var panic = (message) => {
+	throw new Error(`[Sury] ${message}`);
+};
+var formatErrorMessage = (error) => {
+	return `${error.path === "" ? "" : `Failed at ${error.path}: `}${error.reason}`;
+};
+var errorClass = SuryError;
+var initialOnAdditionalItems = "strip";
+var initialDefaultFlag = valFlagNone;
+var globalConfig = {
+	m: formatErrorMessage,
+	d: void 0,
+	a: initialOnAdditionalItems,
+	f: initialDefaultFlag
+};
+var valueOptions = {};
+var configurableValueOptions = { configurable: true };
+var valKey = "value";
+var reversedKey = "r";
+var SchemaCtor = Schema;
+var baseSchema = (tag, selfReverse) => {
+	const schema = new SchemaCtor();
+	schema.type = tag;
+	schema.seq = seq++;
+	if (selfReverse) {
+		valueOptions[valKey] = schema;
+		Object.defineProperty(schema, reversedKey, valueOptions);
+	}
+	return schema;
+};
+var noopDecoder = (input) => {
+	return input;
+};
+var factoryCache = {};
+var cached = (key, tag, init) => {
+	const existing = factoryCache[key];
+	if (existing !== void 0) return existing;
+	else {
+		const schema = baseSchema(tag, true);
+		init(schema);
+		factoryCache[key] = schema;
+		return schema;
+	}
+};
+var unknown = baseSchema(unknownTag, true);
+unknown.decoder = noopDecoder;
+var copySchema = (schema) => {
+	const c = Object.assign(new SchemaCtor(), schema);
+	c.seq = seq++;
+	return c;
+};
+var updateOutput = (schema, fn) => {
+	const root = copySchema(schema);
+	let mut = root;
+	while (mut.to !== void 0) {
+		const next = copySchema(mut.to);
+		mut.to = next;
+		mut = next;
+	}
+	fn(mut);
+	return root;
+};
+var pathEmpty = "";
+var pathDynamic = "[]";
+var inlinedValueFromString = (str) => {
+	return str.includes("\"") || str.includes("\n") ? JSON.stringify(str) : `"${str}"`;
+};
+var pathFromInlinedLocation = (inlinedLocation) => {
+	return `[${inlinedLocation}]`;
+};
+var pathFromLocation = (location) => {
+	return `[${inlinedValueFromString(location)}]`;
+};
+var pathToArray = (path) => {
+	return path === "" ? [] : JSON.parse(path.split(`"]["`).join(`","`));
+};
+var pathFromArray = (array2) => {
+	switch (array2.length) {
+		case 0: return "";
+		case 1: return pathFromLocation(array2[0]);
+		default: return array2.map(pathFromLocation).join("");
+	}
+};
+var pathConcat = (path, concatedPath) => {
+	return path + concatedPath;
+};
+function _var() {
+	return this.i;
+}
+function _bondVar() {
+	return this.b.v();
+}
+function _prevVar() {
+	return this.prev.v();
+}
+function _notVarBeforeValidation() {
+	const val = this;
+	const v = B_varWithoutAllocation(val.g);
+	val.cp = `let ${v}=${val.i};`;
+	val.i = v;
+	val.v = _var;
+	return v;
+}
+function _notVarAtParent() {
+	const val = this;
+	const parent = val.p;
+	if (parent.fz) {
+		val.v = _var;
+		return val.i;
+	} else {
+		const v = B_varWithoutAllocation(val.g);
+		B_hoistDecl(parent, `${v}=${val.i}`);
+		val.v = _var;
+		val.i = v;
+		return v;
+	}
+}
+function _notVar() {
+	const val = this;
+	if (val.fz) {
+		val.v = _var;
+		val.i = `(${val.i})`;
+		return val.i;
+	} else {
+		const v = B_varWithoutAllocation(val.g);
+		if (val.prev !== void 0) if (val.i === "") val.cp = `let ${v};` + val.cp;
+		else val.cp = val.cp + `let ${v}=${val.i};`;
+		else if (val.i === "") B_hoistDecl(val, v);
+		else B_hoistDecl(val, `${v}=${val.i}`);
+		val.v = _var;
+		val.i = v;
+		return v;
+	}
+}
+var operationArgVar = "i";
+var failInvalidType = (input) => {
+	const em = input.e.errorMessage;
+	return B_invalidInputBuilder(void 0, void 0, em !== void 0 ? em.type !== void 0 ? em.type : em._ : void 0)(input);
+};
+var B_embed = (b, value) => {
+	const e = b.g.e;
+	const l = e.length;
+	e[l] = value;
+	return `e[${l}]`;
+};
+var B_inlineConst = (b, schema) => {
+	const tagFlag = tagFlags[schema.type];
+	const const_ = schema.const;
+	if (flagUnsafeHas(tagFlag, tagFlagUndefined)) return "void 0";
+	else if (flagUnsafeHas(tagFlag, tagFlagString)) return inlinedValueFromString(const_);
+	else if (flagUnsafeHas(tagFlag, tagFlagBigint)) return const_ + "n";
+	else if (flagUnsafeHas(tagFlag, 28672)) return B_embed(b, schema.const);
+	else return const_;
+};
+var B_inlineLocation = (global2, location) => {
+	const key = `"${location}"`;
+	const cached2 = global2[key];
+	if (cached2 !== void 0) return cached2;
+	else {
+		const inlinedLocation = inlinedValueFromString(location);
+		global2[key] = inlinedLocation;
+		return inlinedLocation;
+	}
+};
+var B_varWithoutAllocation = (global2) => {
+	const newCounter = global2.v + 1;
+	global2.v = newCounter;
+	return `v${newCounter}`;
+};
+var B_hoistDecl = (owner, decl) => {
+	owner.hd = owner.hd === "" ? decl : owner.hd + "," + decl;
+};
+var B_operationArg = (schema, expected, flag, defs) => {
+	return {
+		cp: "",
+		hd: "",
+		v: _var,
+		i: operationArgVar,
+		f: valFlagNone,
+		s: schema,
+		e: expected,
+		path: pathEmpty,
+		g: {
+			d: defs,
+			o: flag,
+			e: [],
+			v: -1
+		}
+	};
+};
+var B_throw = (errorDetails) => {
+	throw new SuryError(errorDetails);
+};
+var B_unsupportedDecode = (b, from, target) => {
+	return B_throw({
+		code: "unsupported_decode",
+		from,
+		to: target,
+		reason: `Can't decode ${toExpression(from)} to ${toExpression(target)}. Use S.to to define a custom decoder`,
+		path: b.path
+	});
+};
+var B_failWithArg = (b, fn, arg) => {
+	return `${B_embed(b, (arg2) => {
+		B_throw(fn(arg2));
+	})}(${arg})`;
+};
+var B_makeInvalidConversionDetails = (input, to, cause) => {
+	if (cause && cause.s === s) {
+		const error = cause;
+		if (!error[shouldPrependPathKey]) error["path"] = pathConcat(input.path, error.path);
+		return error;
+	} else {
+		let reason;
+		if (cause instanceof Error) {
+			const text = "" + cause;
+			if (text.startsWith("Error: ")) reason = text.slice(7);
+			else reason = text;
+		} else reason = stringify(cause);
+		return {
+			code: "invalid_conversion",
+			from: input.s,
+			to,
+			cause,
+			path: input.path,
+			reason
+		};
+	}
+};
+var B_receivedSchema = (val) => {
+	return val.prev !== void 0 ? val.prev.s : val.s;
+};
+var B_makeInvalidInputDetails = (expected, received, path, input, includeInput, unionErrors, reasonOverride) => {
+	let reasonRef = reasonOverride !== void 0 ? reasonOverride : `Expected ${toExpression(expected)}, received ${includeInput ? stringify(input) : toExpression(received)}`;
+	if (unionErrors !== void 0) {
+		const caseErrors = unionErrors;
+		const seenReasons = /* @__PURE__ */ new Set();
+		for (let idx = 0; idx < caseErrors.length; idx++) {
+			const caseError = caseErrors[idx];
+			const caseReason = caseError.reason.split("\n").join("\n  ");
+			const line = `
+- ${caseError.path === "" ? "" : `At ${caseError.path}: `}${caseReason}`;
+			if (!seenReasons.has(line)) {
+				seenReasons.add(line);
+				reasonRef = reasonRef + line;
+			}
+		}
+	}
+	const details = {
+		code: "invalid_input",
+		expected,
+		received,
+		path,
+		reason: reasonRef,
+		unionErrors
+	};
+	if (includeInput) details.input = input;
+	return details;
+};
+var B_invalidInputBuilder = (expected, extraPath = pathEmpty, reasonOverride, includeInput = true) => {
+	return (input) => {
+		const expected_ = expected !== void 0 ? expected : input.e;
+		const received = B_receivedSchema(input);
+		const path = extraPath === pathEmpty ? input.path : pathConcat(input.path, extraPath);
+		return (value) => B_makeInvalidInputDetails(expected_, received, path, value, includeInput, void 0, reasonOverride);
+	};
+};
+var B_failWithErrorMessage = (key, defaultMessage) => {
+	return (input) => {
+		const em = input.e.errorMessage;
+		const override = em !== void 0 ? em[key] !== void 0 ? em[key] : em["_"] : void 0;
+		const m = override !== void 0 ? override : defaultMessage;
+		if (m !== void 0) return B_invalidInputBuilder(void 0, void 0, m)(input);
+		else return failInvalidType(input);
+	};
+};
+var B_embedInvalidInput = (input, expected = input.e) => {
+	return B_failWithArg(input, B_invalidInputBuilder(expected)(input), input.v());
+};
+var B_emitChecks = (val, inputVar) => {
+	const checks = val.vc;
+	const len = checks.length;
+	if (len === 1) {
+		const check = checks[0];
+		return `${check.c(inputVar)}||${B_failWithArg(val, check.f(val), inputVar)};`;
+	} else {
+		let out = "";
+		let i = 0;
+		while (i < len) {
+			const head = checks[i];
+			const fail = head.f;
+			let cond = head.c(inputVar);
+			i = i + 1;
+			while (i < len && checks[i].f === fail) {
+				cond = cond + "&&" + checks[i].c(inputVar);
+				i = i + 1;
+			}
+			out = out + `${cond}||${B_failWithArg(val, fail(val), inputVar)};`;
+		}
+		return out;
+	}
+};
+var B_isHoistable = (val) => {
+	return val.t === true ? val.prev.t !== true && val.cp === "" : true;
+};
+var B_merge = (val, hoistCond) => {
+	let current = val;
+	let code = "";
+	while (current !== void 0) {
+		const val2 = current;
+		current = val2.prev;
+		let currentCode = "";
+		if (val2.vc) {
+			if (hoistCond !== void 0 && B_isHoistable(val2)) {
+				const inputVar = current.v();
+				const allChecks = val2.vc;
+				let localHoist = "";
+				for (let i = 0; i < allChecks.length; i++) {
+					const check = allChecks[i];
+					const condCode = check.c(inputVar);
+					if (check.f === failInvalidType) if (localHoist) localHoist = `${localHoist}&&${condCode}`;
+					else localHoist = condCode;
+					else if (val2.e.noValidation !== true) currentCode = currentCode + `${condCode}||${B_failWithArg(val2, check.f(val2), inputVar)};`;
+				}
+				if (localHoist) {
+					const cond = hoistCond;
+					if (cond.contents) cond.contents = `${localHoist}&&${cond.contents}`;
+					else cond.contents = localHoist;
+				}
+			} else if (val2.e.noValidation !== true) currentCode = B_emitChecks(val2, current.v());
+		}
+		if (val2.hd !== "") currentCode = currentCode + `let ${val2.hd};`;
+		val2.fz = true;
+		currentCode = val2.cp + currentCode;
+		code = currentCode + code;
+	}
+	return code;
+};
+var B_linkVar = (val, nextVal) => {
+	const valVar = val.v.bind(val);
+	val.v = () => {
+		const v = valVar();
+		nextVal.i = v;
+		nextVal.v = _var;
+		return v;
+	};
+};
+var B_next = (prev, initial, schema, expected = prev.e) => {
+	return {
+		prev,
+		v: _notVar,
+		i: initial,
+		f: valFlagNone,
+		s: schema,
+		e: expected,
+		cp: "",
+		hd: "",
+		path: prev.path,
+		g: prev.g,
+		t: true,
+		d: prev.d
+	};
+};
+var B_refine = (val, schema = val.s, checks, expected = val.e) => {
+	const shouldLink = val.v !== _var;
+	const nextVal = {
+		prev: val,
+		i: val.i,
+		v: shouldLink ? _prevVar : _var,
+		f: val.f,
+		s: schema,
+		e: expected,
+		cp: "",
+		hd: "",
+		vc: checks,
+		path: val.path,
+		g: val.g,
+		t: val.t,
+		d: val.d
+	};
+	if (shouldLink) B_linkVar(val, nextVal);
+	return nextVal;
+};
+var B_pushCheck = (val, check) => {
+	if (val.vc !== void 0) val.vc.push(check);
+	else val.vc = [check];
+};
+var B_markOutput = (val, valInput) => {
+	let deferredInputChecks;
+	const inputRefiner = valInput.e.inputRefiner;
+	if (inputRefiner !== void 0) {
+		const checks = inputRefiner(valInput);
+		if (checks.length > 0) if (valInput.prev !== void 0) {
+			for (let i = 0; i < checks.length; i++) B_pushCheck(valInput, checks[i]);
+			deferredInputChecks = void 0;
+		} else deferredInputChecks = checks;
+		else deferredInputChecks = void 0;
+	} else deferredInputChecks = void 0;
+	let outputChecks;
+	const refiner = val.e.refiner;
+	if (refiner !== void 0) {
+		const checks = refiner(val);
+		outputChecks = checks.length > 0 ? checks : void 0;
+	} else outputChecks = void 0;
+	let result;
+	if (deferredInputChecks !== void 0 && outputChecks !== void 0) result = B_refine(val, void 0, deferredInputChecks.concat(outputChecks));
+	else if (deferredInputChecks !== void 0) result = B_refine(val, void 0, deferredInputChecks);
+	else if (outputChecks !== void 0) result = B_refine(val, void 0, outputChecks);
+	else result = val;
+	result.io = true;
+	return result;
+};
+var B_hoistChildChecks = (parent, child, key) => {
+	if (child.vc) {
+		const pathAppend = pathFromInlinedLocation(B_inlineLocation(parent.g, key));
+		child.vc.forEach((check) => {
+			B_pushCheck(parent, {
+				c: (inputVar) => check.c(inputVar + pathAppend),
+				f: check.f
+			});
+		});
+		child.vc = void 0;
+	}
+};
+var B_dynamicScope = (from, locationVar) => {
+	const schemaAdditionalItems = from.s.additionalItems;
+	const expectedAdditionalItems = from.e.additionalItems;
+	return {
+		v: _notVarBeforeValidation,
+		i: `${from.v()}[${locationVar}]`,
+		f: from.f,
+		s: schemaAdditionalItems !== void 0 && typeof schemaAdditionalItems !== "string" ? schemaAdditionalItems : unknown,
+		e: expectedAdditionalItems !== void 0 && typeof expectedAdditionalItems !== "string" ? expectedAdditionalItems : unknown,
+		cp: "",
+		hd: "",
+		p: from,
+		path: pathEmpty,
+		g: from.g
+	};
+};
+var B_nextConst = (from, schema, expected) => {
+	return B_next(from, B_inlineConst(from, schema), schema, expected);
+};
+var B_asyncVal = (from, initial) => {
+	const v = B_next(from, initial, from.s);
+	v.f = valFlagAsync;
+	return v;
+};
+var B_addObjectField = (objectVal, location, val) => {
+	if (objectVal.s.type === arrayTag) objectVal.s.items.push(val.s);
+	else {
+		if (!val.o) objectVal.s.required.push(location);
+		objectVal.s.properties[location] = val.s;
+	}
+	if (flagUnsafeHas(val.f, valFlagAsync)) val.v();
+	objectVal.cp = objectVal.cp + B_merge(val);
+	objectVal.d[location] = val;
+};
+var B_mergeObjectFields = (target, vals) => {
+	for (const location of Object.keys(vals)) B_addObjectField(target, location, vals[location]);
+};
+var B_addKey = (objVal, key, value) => {
+	return `${objVal.v()}[${key}]=${value.i}`;
+};
+var B_scope = (val) => {
+	const shouldLink = val.v !== _var;
+	const nextVal = {
+		i: val.i,
+		s: val.s,
+		e: val.e,
+		f: flagNone,
+		path: val.path,
+		g: val.g,
+		v: shouldLink ? _bondVar : _var,
+		b: val,
+		cp: "",
+		hd: "",
+		u: false,
+		t: false,
+		io: val.io,
+		d: val.d
+	};
+	if (shouldLink) B_linkVar(val, nextVal);
+	return nextVal;
+};
+var B_embedTransformation = (input, fn, isAsync2) => {
+	const outputVar = B_varWithoutAllocation(input.g);
+	const output = B_next(input, outputVar, unknown, input.e.to);
+	output.v = _var;
+	if (isAsync2) {
+		if (!flagUnsafeHas(input.g.o, flagAsync)) B_throw({
+			code: "invalid_operation",
+			path: pathEmpty,
+			reason: "Encountered unexpected async transform or refine. Use parseAsyncOrThrow operation instead"
+		});
+		output.f |= valFlagAsync;
+	}
+	const embeddedFn = B_embed(input, fn);
+	const failure = `${B_failWithArg(output, (e) => B_makeInvalidConversionDetails(input, unknown, e), `x`)}`;
+	output.cp = `let ${outputVar};try{${outputVar}=${embeddedFn}(${input.vc ? input.v() : input.i})${isAsync2 ? `.catch(x=>${failure})` : ""}}catch(x){${failure}}`;
+	return output;
+};
+var B_effectCtx = (input) => {
+	return { fail: (message, path = pathEmpty) => {
+		const error = new SuryError(B_invalidInputBuilder(void 0, path, message, false)(input)(void 0));
+		error[shouldPrependPathKey] = 1;
+		throw error;
+	} };
+};
+var B_invalidOperation = (val, description) => {
+	return B_throw({
+		code: "invalid_operation",
+		reason: description,
+		path: val.path
+	});
+};
+var B_mergeWithCatch = (val, catchFn, appendSafe) => {
+	const valCode = B_merge(val);
+	if (valCode === "" && !flagUnsafeHas(val.f, valFlagAsync)) return valCode + (appendSafe !== void 0 ? appendSafe() : "");
+	else {
+		const errorVar = B_varWithoutAllocation(val.g);
+		const catchCode = `${catchFn(errorVar)};throw ${errorVar}`;
+		if (flagUnsafeHas(val.f, valFlagAsync)) val.i = `${val.i}.catch(${errorVar}=>{${catchCode}})`;
+		return `try{${valCode}${appendSafe !== void 0 ? appendSafe() : ""}}catch(${errorVar}){${catchCode}}`;
+	}
+};
+var B_mergeWithPathPrepend = (val, parent, locationVar, appendSafe) => {
+	if (val.path === pathEmpty && locationVar === void 0) return B_merge(val);
+	else return B_mergeWithCatch(val, (errorVar) => `${errorVar}.path=${parent.path === "" ? "" : `${inlinedValueFromString(parent.path)}+`}${locationVar !== void 0 ? `'["'+${locationVar}+'"]'+` : ""}${errorVar}.path`, appendSafe);
+};
+function noopOperation(i) {
+	return i;
+}
+noopOperation["embedded"] = immutableEmptyArray;
+var int32FormatValidation = (inputVar) => {
+	return `${inputVar}<=2147483647&&${inputVar}>=-2147483648&&${inputVar}%1===0`;
+};
+var typeofCond = (tag) => (inputVar) => `typeof ${inputVar}==="${tag}"`;
+var nanCond = (inputVar) => `Number.isNaN(${inputVar})`;
+var isArrayCond = (inputVar) => `Array.isArray(${inputVar})`;
+var objectTagCond = (inputVar) => `${typeofCond(objectTag)(inputVar)}&&${inputVar}`;
+var instanceofCond = (b, class_) => (inputVar) => `${inputVar} instanceof ${B_embed(b, class_)}`;
+var B_refineTypeofUnknown = (input, tag) => {
+	return B_refine(input, input.e, [{
+		c: typeofCond(tag),
+		f: failInvalidType
+	}]);
+};
+var B_nextVar = (input, expected) => {
+	const output = B_next(input, B_varWithoutAllocation(input.g), expected);
+	output.v = _var;
+	return output;
+};
+var numberDecoder = (input) => {
+	const inputTagFlag = tagFlags[input.s.type];
+	if (flagUnsafeHas(inputTagFlag, tagFlagUnknown)) {
+		const checks = [{
+			c: typeofCond(numberTag),
+			f: failInvalidType
+		}];
+		if (input.e.format === "int32") checks.push({
+			c: int32FormatValidation,
+			f: failInvalidType
+		});
+		else if (!flagUnsafeHas(input.g.o, flagDisableNanNumberValidation)) checks.push({
+			c: (inputVar) => `!${nanCond(inputVar)}`,
+			f: failInvalidType
+		});
+		return B_refine(input, input.e, checks);
+	} else if (flagUnsafeHas(inputTagFlag, tagFlagString)) {
+		const output = B_nextVar(input, input.e);
+		output.cp = `let ${output.i}=+${input.v()};`;
+		output.vc = [{
+			c: (_inputVar) => input.e.format === "int32" ? int32FormatValidation(output.i) : `!${nanCond(output.i)}`,
+			f: failInvalidType
+		}];
+		return output;
+	} else if (!flagUnsafeHas(inputTagFlag, tagFlagNumber)) return B_unsupportedDecode(input, input.s, input.e);
+	else if (input.s.format !== input.e.format && input.e.format === "int32") return B_refine(input, input.e, [{
+		c: int32FormatValidation,
+		f: failInvalidType
+	}]);
+	else return input;
+};
+var float = () => cached(numberTag, numberTag, (s2) => {
+	s2.decoder = numberDecoder;
+});
+var int = () => cached("i", numberTag, (s2) => {
+	s2.format = "int32";
+	s2.decoder = numberDecoder;
+});
+var inputToString = (input) => {
+	return B_next(input, `""+${input.i}`, string());
+};
+var stringDecoderFn = (input) => {
+	const inputTagFlag = tagFlags[input.s.type];
+	if (flagUnsafeHas(inputTagFlag, tagFlagUnknown)) return B_refineTypeofUnknown(input, stringTag);
+	else if (flagUnsafeHas(inputTagFlag, 3132) && isLiteral(input.s)) {
+		const const_ = "" + input.s.const;
+		const schema = baseSchema(stringTag, false);
+		schema.const = const_;
+		return B_next(input, `"${const_}"`, schema);
+	} else if (flagUnsafeHas(inputTagFlag, 1036)) return inputToString(input);
+	else if (!flagUnsafeHas(inputTagFlag, tagFlagString)) return B_unsupportedDecode(input, input.s, input.e);
+	else return input;
+};
+var string = () => {
+	return cached(stringTag, stringTag, (s2) => {
+		s2.decoder = stringDecoderFn;
+	});
+};
+var booleanDecoder = (input) => {
+	const inputTagFlag = tagFlags[input.s.type];
+	if (flagUnsafeHas(inputTagFlag, tagFlagUnknown)) return B_refineTypeofUnknown(input, booleanTag);
+	else if (flagUnsafeHas(inputTagFlag, tagFlagString)) {
+		const output = B_nextVar(input, input.e);
+		const inputVar = input.v();
+		output.cp = `let ${output.i};(${output.i}=${inputVar}==="true")||${inputVar}==="false"||${B_embedInvalidInput(input)};`;
+		return output;
+	} else if (!flagUnsafeHas(inputTagFlag, tagFlagBoolean)) return B_unsupportedDecode(input, input.s, input.e);
+	else return input;
+};
+var bool = () => cached(booleanTag, booleanTag, (s2) => {
+	s2.decoder = booleanDecoder;
+});
+var bigintDecoder = (input) => {
+	const inputTagFlag = tagFlags[input.s.type];
+	if (flagUnsafeHas(inputTagFlag, tagFlagUnknown)) return B_refineTypeofUnknown(input, bigintTag);
+	else if (flagUnsafeHas(inputTagFlag, tagFlagString)) {
+		const output = B_nextVar(input, input.e);
+		output.cp = `let ${output.i};try{${output.i}=BigInt(${input.v()})}catch(_){${B_embedInvalidInput(input)}}`;
+		return output;
+	} else if (flagUnsafeHas(inputTagFlag, tagFlagNumber)) return B_next(input, `BigInt(${input.i})`, input.e);
+	else if (!flagUnsafeHas(inputTagFlag, tagFlagBigint)) return B_unsupportedDecode(input, input.s, input.e);
+	else return input;
+};
+var bigint = () => cached(bigintTag, bigintTag, (s2) => {
+	s2.decoder = bigintDecoder;
+});
+var symbolDecoder = (input) => {
+	const inputTagFlag = tagFlags[input.s.type];
+	if (flagUnsafeHas(inputTagFlag, tagFlagUnknown)) return B_refineTypeofUnknown(input, symbolTag);
+	else if (!flagUnsafeHas(inputTagFlag, tagFlagSymbol)) return B_unsupportedDecode(input, input.s, input.e);
+	else return input;
+};
+var symbol = () => cached(symbolTag, symbolTag, (s2) => {
+	s2.decoder = symbolDecoder;
+});
+var setHas = (has, tag) => {
+	has[flagUnsafeHas(tagFlags[tag], 768) ? unknownTag : tag] = true;
+};
+var jsonName = `JSON`;
+var literalDecoder = (input) => {
+	const expectedSchema = input.e;
+	if (expectedSchema.noValidation && !input.u) return B_nextConst(input, expectedSchema);
+	else if (isLiteral(input.s)) if (input.s.const === expectedSchema.const) return input;
+	else return B_nextConst(input, expectedSchema);
+	else {
+		const schemaTagFlag = tagFlags[expectedSchema.type];
+		if (flagUnsafeHas(tagFlags[input.s.type], tagFlagString) && flagUnsafeHas(schemaTagFlag, 3132)) {
+			const stringConstSchema = baseSchema(stringTag, false);
+			stringConstSchema.const = "" + expectedSchema.const;
+			const stringConstVal = B_nextConst(input, stringConstSchema, stringConstSchema);
+			stringConstVal.vc = [{
+				c: (inputVar) => `${inputVar}==="${stringConstSchema.const}"`,
+				f: failInvalidType
+			}];
+			return B_nextConst(stringConstVal, expectedSchema, expectedSchema);
+		} else if (flagUnsafeHas(schemaTagFlag, tagFlagNaN)) return B_refine(input, expectedSchema, [{
+			c: nanCond,
+			f: failInvalidType
+		}]);
+		else return B_refine(input, expectedSchema, [{
+			c: (inputVar) => `${inputVar}===${B_inlineConst(input, expectedSchema)}`,
+			f: failInvalidType
+		}]);
+	}
+};
+var unit = () => cached(undefinedTag, undefinedTag, (s2) => {
+	s2.const = void 0;
+	s2.decoder = literalDecoder;
+});
+var void_ = () => cached("void", undefinedTag, (s2) => {
+	s2.const = void 0;
+	s2.name = "void";
+	s2.decoder = literalDecoder;
+});
+var nullLiteral = () => cached(nullTag, nullTag, (s2) => {
+	s2.const = null;
+	s2.decoder = literalDecoder;
+});
+var nan = () => cached(nanTag, nanTag, (s2) => {
+	s2.const = NaN;
+	s2.decoder = literalDecoder;
+});
+var Literal_parse = (value) => {
+	if (value === null) return nullLiteral();
+	else {
+		const tag = typeof value;
+		if (tag === undefinedTag) return unit();
+		else if (tag === numberTag && Number.isNaN(value)) return nan();
+		else if (tag === objectTag) {
+			const s2 = baseSchema(instanceTag, true);
+			s2.class = value["constructor"];
+			s2.const = value;
+			s2.decoder = literalDecoder;
+			return s2;
+		} else {
+			const s2 = baseSchema(tag, true);
+			s2.const = value;
+			s2.decoder = literalDecoder;
+			return s2;
+		}
+	}
+};
+var parse = (input) => {
+	let result = input;
+	let appliedEncoderRef = void 0;
+	let loopCount = 0;
+	while (!result.io || result.e.to) {
+		const appliedEncoder = appliedEncoderRef;
+		appliedEncoderRef = void 0;
+		const loopInput = result;
+		loopCount = loopCount + 1;
+		if (loopCount > 50) throw /* @__PURE__ */ new Error("Loop count exceeded 50");
+		if (loopInput.e["$defs"]) if (loopInput.g.d) Object.assign(loopInput.g.d, loopInput.e["$defs"]);
+		else loopInput.g.d = loopInput.e["$defs"];
+		if (flagUnsafeHas(loopInput.f, valFlagAsync)) {
+			const operationInputVar = loopInput.v();
+			const operationInput = B_scope(loopInput);
+			const operationOutput = parse(operationInput);
+			const operationCode = B_merge(operationOutput);
+			if (operationInput.i !== operationOutput.i || operationCode !== "") result = B_next(loopInput, `${operationInputVar}.then(${operationInputVar}=>{${operationCode}return ${operationOutput.i}})`, operationOutput.s, operationOutput.e);
+			else result = B_refine(loopInput, operationOutput.s, void 0, operationOutput.e);
+			result.f |= valFlagAsync;
+			result.io = true;
+		} else if (loopInput.io) {
+			const to = loopInput.e.to;
+			if (loopInput.e.parser !== void 0) result = loopInput.e.parser(loopInput);
+			else result = B_refine(result, void 0, void 0, to);
+		} else {
+			const maybeEncoder = loopInput.s.encoder;
+			if (maybeEncoder && maybeEncoder !== appliedEncoder && loopInput.s !== loopInput.e && loopInput.e.type !== unknownTag) result = maybeEncoder(loopInput, loopInput.e);
+			if (loopInput !== result) appliedEncoderRef = maybeEncoder;
+			else {
+				result = loopInput.e.decoder(loopInput);
+				if (!result.io) result = B_markOutput(result, result);
+			}
+		}
+	}
+	return result;
+};
+var parseDynamic = (input) => {
+	try {
+		return parse(input);
+	} catch (exn) {
+		const error = getOrRethrow(exn);
+		error.path = pathConcat(input.p !== void 0 ? input.p.path : pathEmpty, pathConcat(pathConcat(input.path, pathDynamic), error.path));
+		throw error;
+	}
+};
+var isAsyncInternal = (schema, defs) => {
+	try {
+		const isAsync2 = flagUnsafeHas(parse(B_operationArg(unknown, schema, flagAsync, defs)).f, valFlagAsync);
+		schema.isAsync = isAsync2;
+		return isAsync2;
+	} catch (exn) {
+		getOrRethrow(exn);
+		return false;
+	}
+};
+var compileDecoder = (schema, expected, flag, defs) => {
+	const input = B_operationArg(isLiteral(schema) ? unknown : schema, expected, flag, defs);
+	const output = parse(input);
+	const code = B_merge(output);
+	const isAsync2 = flagUnsafeHas(output.f, valFlagAsync);
+	expected.isAsync = isAsync2;
+	expected.hasTransform = output.t === true;
+	if (code === "" && (output === input || output.i === input.i) && !flagUnsafeHas(flag, flagAsync)) return noopOperation;
+	else {
+		let inlinedOutput = output.i;
+		if (flagUnsafeHas(flag, flagAsync) && !isAsync2 && !defs) inlinedOutput = `Promise.resolve(${inlinedOutput})`;
+		const inlinedFunction = `${operationArgVar}=>{${code}return ${inlinedOutput}}`;
+		const fn = new Function("e", "s", `return ${inlinedFunction}`)(input.g.e, s);
+		fn.embedded = input.g.e;
+		return fn;
+	}
+};
+var getOutputSchema = (schema) => {
+	if (schema.to !== void 0) return getOutputSchema(schema.to);
+	else return schema;
+};
+var reverse = (schema) => {
+	const schemaRecord = schema;
+	if (reversedKey in schemaRecord) return schemaRecord[reversedKey];
+	else {
+		let reversedHead = void 0;
+		let current = schema;
+		while (current) {
+			const mut = copySchema(current);
+			const next = mut.to;
+			if (reversedHead === void 0) delete mut.to;
+			else mut.to = reversedHead;
+			const parser = mut.parser;
+			if (mut.serializer !== void 0) mut.parser = mut.serializer;
+			else delete mut.parser;
+			if (parser !== void 0) mut.serializer = parser;
+			else delete mut.serializer;
+			const refiner = mut.refiner;
+			if (mut.inputRefiner !== void 0) mut.refiner = mut.inputRefiner;
+			else delete mut.refiner;
+			if (refiner !== void 0) mut.inputRefiner = refiner;
+			else delete mut.inputRefiner;
+			const fromDefault = mut.fromDefault;
+			if (mut.default !== void 0) mut.fromDefault = mut.default;
+			else delete mut.fromDefault;
+			if (fromDefault !== void 0) mut.default = fromDefault;
+			else delete mut.default;
+			if (mut.items !== void 0) mut.items = mut.items.map(reverse);
+			if (mut.properties !== void 0) {
+				const properties = mut.properties;
+				const newProperties = {};
+				const keys = Object.keys(properties);
+				for (let idx = 0; idx <= keys.length - 1; idx++) {
+					const key = keys[idx];
+					newProperties[key] = reverse(properties[key]);
+				}
+				mut.properties = newProperties;
+			}
+			if (typeof mut.additionalItems === objectTag) mut.additionalItems = reverse(mut.additionalItems);
+			if (mut.anyOf !== void 0) {
+				const anyOf = mut.anyOf;
+				const has = {};
+				const newAnyOf = [];
+				for (let idx = 0; idx <= anyOf.length - 1; idx++) {
+					const s2 = anyOf[idx];
+					const reversed = reverse(s2);
+					newAnyOf.push(reversed);
+					setHas(has, reversed.type);
+				}
+				mut.has = has;
+				mut.anyOf = newAnyOf;
+			}
+			if (mut["$defs"] !== void 0) {
+				const defs = mut["$defs"];
+				const reversedDefs = {};
+				const defsKeys = Object.keys(defs);
+				for (let idx = 0; idx <= defsKeys.length - 1; idx++) {
+					const key = defsKeys[idx];
+					reversedDefs[key] = reverse(defs[key]);
+				}
+				mut["$defs"] = reversedDefs;
+			}
+			reversedHead = mut;
+			current = next;
+		}
+		const r = reversedHead;
+		valueOptions[valKey] = r;
+		Object.defineProperty(schema, reversedKey, valueOptions);
+		valueOptions[valKey] = schema;
+		Object.defineProperty(r, reversedKey, valueOptions);
+		return r;
+	}
+};
+function getDecoder(..._args) {
+	const args = arguments;
+	let idx = 0;
+	let flag = void 0;
+	let keyRef = "";
+	let maxSeq = 0;
+	let cacheTarget = void 0;
+	while (flag === void 0) {
+		const arg = args[idx];
+		if (!arg) {
+			const f = globalConfig.f;
+			flag = f;
+			keyRef = keyRef + "-" + f;
+		} else if (typeof arg === numberTag) {
+			const f = arg | globalConfig.f;
+			flag = f;
+			keyRef = keyRef + "-" + f;
+		} else {
+			const schema = arg;
+			const seq2 = schema.seq;
+			if (seq2 > maxSeq) {
+				maxSeq = seq2;
+				cacheTarget = schema;
+			}
+			keyRef = keyRef + seq2 + "-";
+			idx = idx + 1;
+		}
+	}
+	if (cacheTarget === void 0) return panic("No schema provided for decoder.");
+	else {
+		const key = keyRef;
+		const cacheTargetRecord = cacheTarget;
+		if (key in cacheTargetRecord) return cacheTargetRecord[key];
+		else {
+			let schema = args[idx - 1];
+			for (let i = idx - 2; i >= 0; i--) {
+				const to = schema;
+				schema = updateOutput(args[i], (mut) => {
+					mut.to = to;
+				});
+			}
+			const f = compileDecoder(schema, schema, flag, void 0);
+			valueOptions[valKey] = f;
+			Object.defineProperty(cacheTarget, key, valueOptions);
+			return f;
+		}
+	}
+}
+var nestedLoc = "BS_PRIVATE_NESTED_SOME_NONE";
+var neverBuilderFn = (input) => {
+	const output = B_refine(input, void 0, void 0, never_());
+	output.cp = B_embedInvalidInput(input) + ";";
+	return output;
+};
+var never_ = () => {
+	return cached(neverTag, neverTag, (s2) => {
+		s2.decoder = neverBuilderFn;
+	});
+};
+var nestedOptionParser = (input) => {
+	const nextSchema = input.e.to;
+	return B_next(input, `{${nestedLoc}:${getOutputSchema(input.e).properties[nestedLoc].const}}`, nextSchema, nextSchema);
+};
+var instanceDecoder = (input) => {
+	const inputTagFlag = tagFlags[input.s.type];
+	if (flagUnsafeHas(inputTagFlag, tagFlagUnknown)) return B_refine(input, input.e, [{
+		c: instanceofCond(input, input.e.class),
+		f: failInvalidType
+	}]);
+	else if (flagUnsafeHas(inputTagFlag, tagFlagInstance) && input.s.class === input.e.class) return input;
+	else return B_unsupportedDecode(input, input.s, input.e);
+};
+var instance = (class_) => {
+	const mut = baseSchema(instanceTag, true);
+	mut.class = class_;
+	mut.decoder = instanceDecoder;
+	return mut;
+};
+var typeCheckCond = (input, schema, inputVar) => {
+	const tagFlag = tagFlags[schema.type];
+	if (flagUnsafeHas(tagFlag, tagFlagObject)) return `${objectTagCond(inputVar)}&&!${isArrayCond(inputVar)}`;
+	else if (flagUnsafeHas(tagFlag, tagFlagArray)) return isArrayCond(inputVar);
+	else if (flagUnsafeHas(tagFlag, tagFlagInstance)) return instanceofCond(input, schema.class)(inputVar);
+	else if (flagUnsafeHas(tagFlag, tagFlagNumber)) {
+		const typeofCheck = typeofCond(numberTag)(inputVar);
+		if (flagUnsafeHas(input.g.o, flagDisableNanNumberValidation)) return typeofCheck;
+		else return `${typeofCheck}&&!${nanCond(inputVar)}`;
+	} else if (flagUnsafeHas(tagFlag, tagFlagNaN)) return nanCond(inputVar);
+	else if (flagUnsafeHas(tagFlag, 48)) return `${inputVar}===${B_inlineConst(input, schema)}`;
+	else if (flagUnsafeHas(tagFlag, 17418)) return typeofCond(schema.type)(inputVar);
+	else return "";
+};
+var isItemSchema = (x) => x !== void 0 && typeof x !== "string";
+var makeObjectVal = (prev, schema) => {
+	return {
+		prev,
+		v: _notVar,
+		i: "",
+		f: valFlagNone,
+		s: schema.type === arrayTag ? {
+			type: arrayTag,
+			items: [],
+			additionalItems: "strict",
+			decoder: arrayDecoder
+		} : {
+			type: objectTag,
+			required: [],
+			properties: /* @__PURE__ */ Object.create(null),
+			additionalItems: "strict",
+			decoder: objectDecoder
+		},
+		e: prev.e,
+		d: /* @__PURE__ */ Object.create(null),
+		t: true,
+		cp: "",
+		hd: "",
+		path: prev.path,
+		g: prev.g
+	};
+};
+var completeObjectVal = (objectVal) => {
+	const isArray = objectVal.s.type === arrayTag;
+	let inline = "";
+	let promiseAllContent = "";
+	let optionalSettingCode = void 0;
+	const keys = Object.keys(objectVal.d);
+	for (let idx = 0; idx < keys.length; idx++) {
+		const key = keys[idx];
+		const val = objectVal.d[key];
+		if (flagUnsafeHas(val.f, valFlagAsync)) promiseAllContent = promiseAllContent + val.i + ",";
+		if (val.o) {
+			const existingFn = optionalSettingCode;
+			optionalSettingCode = (objectVar) => {
+				return (existingFn === void 0 ? "" : existingFn(objectVar)) + `if(${val.v()}!==void 0){${objectVar}[${B_inlineLocation(objectVal.g, key)}]=${val.i}}`;
+			};
+		} else inline = inline + (isArray ? `${val.i}` : `${B_inlineLocation(objectVal.g, key)}:${val.i}`) + ",";
+	}
+	objectVal.i = isArray ? "[" + inline + "]" : "{" + inline + "}";
+	const valWithRequired = objectVal;
+	if (promiseAllContent) {
+		const operationInput = B_scope(valWithRequired);
+		operationInput.io = true;
+		const operationOutput = parse(operationInput);
+		const operationCode = B_merge(operationOutput);
+		if (operationCode === "" && promiseAllContent === `${operationOutput.i},`) valWithRequired.i = operationOutput.i;
+		else valWithRequired.i = `Promise.all([${promiseAllContent}]).then(([${promiseAllContent}])=>{${operationCode}return ${operationOutput.i}})`;
+		valWithRequired.f |= valFlagAsync;
+		valWithRequired.s = operationOutput.s;
+		valWithRequired.e = operationOutput.e;
+		valWithRequired.io = true;
+		return valWithRequired;
+	} else if (optionalSettingCode === void 0) return valWithRequired;
+	else {
+		const code = optionalSettingCode(valWithRequired.v());
+		const output = B_refine(valWithRequired);
+		output.cp = output.cp + code;
+		return output;
+	}
+};
+var array = (item) => {
+	const itemInternal = item;
+	const mut = baseSchema(arrayTag, itemInternal.r === itemInternal);
+	mut.additionalItems = itemInternal;
+	mut.items = immutableEmptyArray;
+	mut.decoder = arrayDecoder;
+	return mut;
+};
+var arrayDecoder = (unknownInput) => {
+	const isUnion = unknownInput.u;
+	const expectedSchema = unknownInput.e;
+	const unknownInputTagFlag = tagFlags[unknownInput.s.type];
+	const expectedItems = expectedSchema.items;
+	const expectedLength = expectedItems.length;
+	let input;
+	if (flagUnsafeHas(unknownInputTagFlag, 129)) {
+		const isArrayInput = flagUnsafeHas(unknownInputTagFlag, tagFlagArray);
+		let schema;
+		if (!isArrayInput) schema = array(unknown);
+		else schema = unknownInput.s;
+		const checks = [];
+		if (!isArrayInput) checks.push({
+			c: isArrayCond,
+			f: failInvalidType
+		});
+		const schemaAdditionalItems = schema.additionalItems;
+		if (!(isItemSchema(schemaAdditionalItems) ? false : schema.items.length === expectedLength)) {
+			const expectedAdditionalItems2 = expectedSchema.additionalItems;
+			if (expectedAdditionalItems2 === "strict") checks.push({
+				c: (inputVar) => `${inputVar}.length===${expectedLength}`,
+				f: failInvalidType
+			});
+			else if (expectedAdditionalItems2 === "strip") checks.push({
+				c: (inputVar) => `${inputVar}.length>=${expectedLength}`,
+				f: failInvalidType
+			});
+		}
+		if (checks.length > 0) input = B_refine(unknownInput, schema, checks);
+		else input = B_refine(unknownInput, schema);
+	} else input = B_unsupportedDecode(unknownInput, unknownInput.s, expectedSchema);
+	let output;
+	const expectedAdditionalItems = expectedSchema.additionalItems;
+	if (isItemSchema(expectedAdditionalItems)) if (expectedAdditionalItems === unknown) output = input;
+	else {
+		const inputVar = input.v();
+		const iteratorVar = B_varWithoutAllocation(input.g);
+		const itemOutput = parseDynamic(B_dynamicScope(input, iteratorVar));
+		const hasTransform = itemOutput.t;
+		const output2 = hasTransform ? B_next(input, `new Array(${inputVar}.length)`, array(itemOutput.s)) : B_refine(input, expectedSchema);
+		const itemCode = B_mergeWithPathPrepend(itemOutput, input, iteratorVar, hasTransform ? () => B_addKey(output2, iteratorVar, itemOutput) : void 0);
+		if (hasTransform || itemCode !== "") output2.cp = output2.cp + `for(let ${iteratorVar}=${expectedLength};${iteratorVar}<${inputVar}.length;++${iteratorVar}){${itemCode}}`;
+		if (flagUnsafeHas(itemOutput.f, valFlagAsync)) output = B_asyncVal(output2, `Promise.all(${output2.i})`);
+		else output = output2;
+	}
+	else {
+		const objectVal = makeObjectVal(input, expectedSchema);
+		let shouldRecreateInput;
+		{
+			const ai = expectedSchema.additionalItems;
+			if (ai === "strict") shouldRecreateInput = false;
+			else if (ai === "strip") {
+				const inputAi = input.s.additionalItems;
+				shouldRecreateInput = isItemSchema(inputAi) ? true : input.s.items.length !== expectedLength;
+			} else shouldRecreateInput = true;
+		}
+		for (let idx = 0; idx < expectedLength; idx++) {
+			const schema = expectedItems[idx];
+			const key = String(idx);
+			const itemInput = valGet(input, key);
+			itemInput.e = schema;
+			itemInput.io = false;
+			itemInput.u = isUnion;
+			const itemOutput = parse(itemInput);
+			if (isUnion && isLiteral(schema)) B_hoistChildChecks(input, itemOutput, key);
+			B_addObjectField(objectVal, key, itemOutput);
+			if (!shouldRecreateInput) shouldRecreateInput = itemOutput.t;
+		}
+		if (shouldRecreateInput) output = completeObjectVal(objectVal);
+		else {
+			const o = B_refine(input, expectedSchema);
+			o.cp = objectVal.cp;
+			o.d = objectVal.d;
+			output = o;
+		}
+	}
+	return B_markOutput(output, input);
+};
+var objectDecoder = (unknownInput) => {
+	const isUnion = unknownInput.u;
+	const expectedSchema = unknownInput.e;
+	const unknownInputTagFlag = tagFlags[unknownInput.s.type];
+	let input;
+	if (flagUnsafeHas(unknownInputTagFlag, 65)) {
+		const isObjectInput = flagUnsafeHas(unknownInputTagFlag, tagFlagObject);
+		let schema;
+		if (!isObjectInput) {
+			const mut = baseSchema(objectTag, false);
+			mut.properties = immutableEmptyObject;
+			mut.additionalItems = unknown;
+			schema = mut;
+		} else schema = unknownInput.s;
+		const checks = [];
+		if (!isObjectInput) {
+			checks.push({
+				c: objectTagCond,
+				f: failInvalidType
+			});
+			if (expectedSchema.additionalItems !== "strip") checks.push({
+				c: (inputVar) => `!${isArrayCond(inputVar)}`,
+				f: failInvalidType
+			});
+		}
+		if (checks.length > 0) input = B_refine(unknownInput, schema, checks);
+		else input = B_refine(unknownInput, schema);
+	} else input = B_unsupportedDecode(unknownInput, unknownInput.s, expectedSchema);
+	const expectedAdditionalItems = expectedSchema.additionalItems;
+	const dictItem = isItemSchema(expectedAdditionalItems) ? expectedAdditionalItems : void 0;
+	const inputAdditionalItems = input.s.additionalItems;
+	const sourceIsDict = isItemSchema(inputAdditionalItems);
+	let output;
+	if (dictItem !== void 0 && dictItem === unknown) output = input;
+	else if (dictItem !== void 0 && sourceIsDict) {
+		const inputVar = input.v();
+		const keyVar = B_varWithoutAllocation(input.g);
+		const itemOutput = parseDynamic(B_dynamicScope(input, keyVar));
+		const hasTransform = itemOutput.t;
+		const output2 = hasTransform ? B_next(input, "{}", dictFactory(itemOutput.s)) : B_refine(input, expectedSchema);
+		const itemCode = B_mergeWithPathPrepend(itemOutput, input, keyVar, hasTransform ? () => B_addKey(output2, keyVar, itemOutput) : void 0);
+		if (hasTransform || itemCode !== "") output2.cp = output2.cp + `for(let ${keyVar} in ${inputVar}){${itemCode}}`;
+		if (flagUnsafeHas(itemOutput.f, valFlagAsync)) {
+			const resolveVar = B_varWithoutAllocation(output2.g);
+			const rejectVar = B_varWithoutAllocation(output2.g);
+			const asyncParseResultVar = B_varWithoutAllocation(output2.g);
+			const counterVar = B_varWithoutAllocation(output2.g);
+			const outputVar = output2.v();
+			output = B_asyncVal(output2, `new Promise((${resolveVar},${rejectVar})=>{let ${counterVar}=Object.keys(${outputVar}).length;for(let ${keyVar} in ${outputVar}){${outputVar}[${keyVar}].then(${asyncParseResultVar}=>{${outputVar}[${keyVar}]=${asyncParseResultVar};if(${counterVar}--===1){${resolveVar}(${outputVar})}},${rejectVar})}})`);
+		} else output = output2;
+	} else if (dictItem !== void 0) {
+		const itemSchema = dictItem;
+		const objectVal = makeObjectVal(input, expectedSchema);
+		const keys = Object.keys(input.s.properties);
+		for (let idx = 0; idx < keys.length; idx++) {
+			const key = keys[idx];
+			const itemInput = valGet(input, key);
+			itemInput.e = itemSchema;
+			itemInput.io = false;
+			itemInput.u = isUnion;
+			B_addObjectField(objectVal, key, parse(itemInput));
+		}
+		output = completeObjectVal(objectVal);
+	} else {
+		const properties = expectedSchema.properties;
+		const keys = Object.keys(properties);
+		const keysCount = keys.length;
+		const objectVal = makeObjectVal(input, expectedSchema);
+		let shouldRecreateInput;
+		{
+			const ai = expectedSchema.additionalItems;
+			if (ai === "strict") shouldRecreateInput = false;
+			else if (ai === "strip") shouldRecreateInput = sourceIsDict || Object.keys(input.s.properties).length !== keysCount;
+			else shouldRecreateInput = true;
+		}
+		const isJsonParent = isItemSchema(inputAdditionalItems) ? inputAdditionalItems.name === jsonName : false;
+		for (let idx = 0; idx < keysCount; idx++) {
+			const key = keys[idx];
+			const schema = properties[key];
+			const itemInput = valGet(input, key);
+			itemInput.e = schema;
+			itemInput.io = false;
+			itemInput.u = isUnion;
+			if (isJsonParent && schema.type === unionTag && schema.has[undefinedTag]) itemInput.i = `(${itemInput.i}??null)`;
+			const itemOutput = parse(itemInput);
+			if (isUnion && isLiteral(schema)) B_hoistChildChecks(input, itemOutput, key);
+			B_addObjectField(objectVal, key, itemOutput);
+			if (!shouldRecreateInput) shouldRecreateInput = itemOutput.t;
+		}
+		if (expectedSchema.additionalItems === "strict" && isItemSchema(inputAdditionalItems)) {
+			const keyVar = B_varWithoutAllocation(objectVal.g);
+			B_hoistDecl(input, keyVar);
+			objectVal.cp = objectVal.cp + `for(${keyVar} in ${input.v()}){if(`;
+			if (keys.length === 0) objectVal.cp = objectVal.cp + "true";
+			else for (let idx = 0; idx < keys.length; idx++) {
+				const key = keys[idx];
+				if (idx !== 0) objectVal.cp = objectVal.cp + "&&";
+				objectVal.cp = objectVal.cp + `${keyVar}!==${B_inlineLocation(input.g, key)}`;
+			}
+			objectVal.cp = objectVal.cp + `){${B_failWithArg(input, (excessFieldName) => ({
+				code: "unrecognized_keys",
+				path: objectVal.path,
+				reason: `Unrecognized key "${excessFieldName}"`,
+				keys: [excessFieldName]
+			}), keyVar)}}}`;
+		}
+		if (shouldRecreateInput) output = completeObjectVal(objectVal);
+		else {
+			const o = B_refine(input, expectedSchema);
+			o.cp = objectVal.cp;
+			o.d = objectVal.d;
+			output = o;
+		}
+	}
+	return B_markOutput(output, input);
+};
+var dictFactory = (item) => {
+	const mut = baseSchema(objectTag, item.r === item);
+	mut.properties = immutableEmptyObject;
+	mut.additionalItems = item;
+	mut.decoder = objectDecoder;
+	return mut;
+};
+var unionToKey = (schema) => {
+	return flagUnsafeHas(tagFlags[schema.type], tagFlagInstance) ? schema.class["name"] : schema.type;
+};
+var unionIsPriority = (tagFlag, byKey) => {
+	return flagUnsafeHas(tagFlag, 8320) && objectTag in byKey || flagUnsafeHas(tagFlag, tagFlagNaN) && numberTag in byKey;
+};
+var unionIsSelfDecodeNoop = (schema) => {
+	const additionalItems = schema.additionalItems;
+	return schema.to === void 0 && schema.parser === void 0 && !flagUnsafeHas(tagFlags[schema.type], tagFlagRef) && (schema.anyOf !== void 0 ? schema.anyOf.every(unionIsSelfDecodeNoop) : true) && (schema.items !== void 0 ? schema.items.every(unionIsSelfDecodeNoop) : true) && (schema.properties !== void 0 ? Object.values(schema.properties).every(unionIsSelfDecodeNoop) : true) && (additionalItems !== void 0 && typeof additionalItems !== "string" ? unionIsSelfDecodeNoop(additionalItems) : true);
+};
+var unionIsWiderSchema = (schemaAnyOf, inputAnyOf) => {
+	return inputAnyOf.every((inputSchema, idx) => {
+		const schema = schemaAnyOf[idx];
+		if (schema !== void 0) return !flagUnsafeHas(tagFlags[inputSchema.type], 9152) && inputSchema.type === schema.type && inputSchema.const === schema.const && inputSchema.to === void 0;
+		else return false;
+	});
+};
+var unionGetToPerCase = (schema) => {
+	return schema.parser === void 0 && schema.to !== void 0 ? schema.to : void 0;
+};
+var unionCanDispatchPerVariant = (inputAnyOf, target) => {
+	return !flagUnsafeHas(tagFlags[getOutputSchema(target).type], tagFlagRef) && !(target.type === unionTag && target.anyOf.some((v) => flagUnsafeHas(tagFlags[v.type], tagFlagRef))) && !inputAnyOf.some((v) => v.to !== void 0 || v.parser !== void 0 || flagUnsafeHas(tagFlags[v.type], tagFlagRef));
+};
+var unionPerVariantVal = (input, target) => {
+	return B_refine(input, unknown, void 0, updateOutput(input.s, (mut) => {
+		mut.to = target;
+	}));
+};
+var unionEncoder = (input, target) => {
+	const inputAnyOf = input.s.anyOf;
+	if (target.type === unionTag && unionGetToPerCase(target) === void 0 && unionIsWiderSchema(target.anyOf, inputAnyOf)) return input;
+	else if (unionCanDispatchPerVariant(inputAnyOf, target)) return unionPerVariantVal(input, target);
+	else return input;
+};
+var unionDecoder = (input) => {
+	const selfSchema = input.e;
+	let schemas = selfSchema.anyOf;
+	const initialInputTagFlag = tagFlags[input.s.type];
+	const toPerCase = unionGetToPerCase(selfSchema);
+	if (input.s === selfSchema && toPerCase === void 0 && schemas.every(unionIsSelfDecodeNoop) || flagUnsafeHas(initialInputTagFlag, tagFlagUnion) && unionIsWiderSchema(schemas, input.s.anyOf) && toPerCase === void 0 || input.io && input.e === input.s) return input;
+	else {
+		if (flagUnsafeHas(initialInputTagFlag, tagFlagUnion) || input.s.encoder === void 0 && flagUnsafeHas(initialInputTagFlag, tagFlagRef)) input.s = unknown;
+		let activeKeyRef = "";
+		if (!flagUnsafeHas(initialInputTagFlag, 769)) {
+			const sourceKey = unionToKey(input.s);
+			let hasNull = false;
+			let hasUndefined = false;
+			const len = schemas.length;
+			let i = 0;
+			while (activeKeyRef === "" && i < len) {
+				const s2 = schemas[i];
+				if (unionToKey(s2) === sourceKey) activeKeyRef = sourceKey;
+				else if (s2.type === nullTag) hasNull = true;
+				else if (s2.type === undefinedTag) hasUndefined = true;
+				i = i + 1;
+			}
+			if (activeKeyRef === "") {
+				if (flagUnsafeHas(initialInputTagFlag, tagFlagUndefined) && hasNull) activeKeyRef = nullTag;
+				else if (flagUnsafeHas(initialInputTagFlag, tagFlagNull) && hasUndefined) activeKeyRef = undefinedTag;
+			}
+		}
+		const activeKey = activeKeyRef;
+		const initialInline = input.i;
+		const fail = (caught2) => {
+			return `${B_embed(input, function() {
+				const args = arguments;
+				B_throw(B_makeInvalidInputDetails(selfSchema, unknown, input.path, args[0], true, args.length > 1 ? Array.from(args).slice(1) : void 0));
+			})}(${input.v()}${caught2})`;
+		};
+		const output = B_refine(input);
+		const outputAnyOf = [];
+		let staticBlockFailure = "";
+		const getArrItemsCode = (arr, isDeopt) => {
+			const typeValidationInput = arr[0];
+			const typeValidationOutput = arr[1];
+			let itemStart = "";
+			let itemEnd = "";
+			let itemNextElse = false;
+			let itemNoop = "";
+			let caught2 = "";
+			let byDiscriminant = {};
+			const preItems = 2;
+			let itemIdx = preItems;
+			const lastIdx2 = arr.length - 1;
+			while (itemIdx <= lastIdx2) {
+				const input2 = B_scope(typeValidationOutput);
+				input2.u = true;
+				input2.t = typeValidationOutput.t;
+				input2.io = false;
+				input2.e = arr[itemIdx];
+				const isLast = itemIdx === lastIdx2;
+				const isFirst = itemIdx === preItems;
+				const isOnlyCase = isFirst && isLast;
+				let withExhaustiveCheck = !isOnlyCase;
+				let itemSkipped = false;
+				let itemCodeRef = "";
+				const itemCondRef = { contents: "" };
+				try {
+					const itemOutput = parse(input2);
+					outputAnyOf.push(itemOutput.s);
+					itemCodeRef = B_merge(itemOutput, itemCondRef);
+					if (itemOutput.t) {
+						output.t = true;
+						if (flagUnsafeHas(itemOutput.f, valFlagAsync)) output.f |= valFlagAsync;
+						const itemVar = typeValidationInput.v();
+						if (itemOutput.i !== itemVar) itemCodeRef = itemCodeRef + `${itemVar}=${itemOutput.i}`;
+					}
+				} catch (exn) {
+					const errorVar = B_embed(input2, getOrRethrow(exn));
+					caught2 = `${caught2},${errorVar}`;
+					if (isDeopt && isOnlyCase) {
+						staticBlockFailure = errorVar;
+						itemSkipped = true;
+					} else if (isLast) {
+						withExhaustiveCheck = false;
+						itemCodeRef = isDeopt ? "throw " + errorVar : fail(caught2);
+					} else itemSkipped = true;
+				}
+				const itemCond = itemCondRef.contents;
+				const itemCode = itemCodeRef;
+				if (!itemSkipped && itemCond) if (itemCode) {
+					const existing = byDiscriminant[itemCond];
+					if (existing !== void 0) if (Array.isArray(existing)) existing.push(itemCode);
+					else byDiscriminant[itemCond] = [existing, itemCode];
+					else byDiscriminant[itemCond] = itemCode;
+				} else itemNoop = itemNoop ? `${itemNoop}||${itemCond}` : itemCond;
+				if (!itemSkipped && (!itemCond || isLast)) {
+					const accedDiscriminants = Object.keys(byDiscriminant);
+					for (let idx = 0; idx < accedDiscriminants.length; idx++) {
+						const discrim = accedDiscriminants[idx];
+						itemStart = itemStart + (itemNextElse ? "else if" : "if") + `(${discrim}){`;
+						const entry = byDiscriminant[discrim];
+						if (!Array.isArray(entry)) itemStart = itemStart + entry + "}";
+						else {
+							let caught3 = "";
+							for (let idx2 = 0; idx2 < entry.length; idx2++) {
+								const code = entry[idx2];
+								const errorVar = `e` + idx2;
+								itemStart = itemStart + `try{${code}}catch(${errorVar}){`;
+								caught3 = `${caught3},${errorVar}`;
+							}
+							itemStart = itemStart + fail(caught3) + "}".repeat(entry.length) + "}";
+						}
+						itemNextElse = true;
+					}
+					byDiscriminant = {};
+				}
+				if (!itemSkipped && !itemCond) if (!itemCode) {
+					itemNoop = "";
+					itemIdx = lastIdx2;
+					withExhaustiveCheck = false;
+				} else {
+					if (itemNoop) {
+						itemStart = itemStart + (itemNextElse ? "else if" : "if") + `(!(${itemNoop})){`;
+						itemEnd = "}" + itemEnd;
+						itemNoop = "";
+						itemNextElse = false;
+					}
+					if (isLast && (isDeopt || !withExhaustiveCheck || isFirst)) {
+						itemStart = itemStart + `${itemNextElse ? "else{" : ""}${itemCode}`;
+						itemEnd = (itemNextElse ? "}" : "") + itemEnd;
+					} else {
+						const errorVar = `e` + (itemIdx - preItems);
+						itemStart = itemStart + `${itemNextElse ? "else{" : ""}try{${itemCode}}catch(${errorVar}){`;
+						itemEnd = (itemNextElse ? "}" : "") + "}" + itemEnd;
+						caught2 = `${caught2},${errorVar}`;
+						itemNextElse = false;
+					}
+				}
+				if (isLast) {
+					if (itemNoop) if (itemStart || caught2) itemStart = itemStart + (itemNextElse ? "else if" : "if") + `(!(${itemNoop})){${fail(caught2)}}`;
+					else B_pushCheck(typeValidationOutput, {
+						c: (_inputVar) => `(${itemNoop})`,
+						f: failInvalidType
+					});
+					else if (withExhaustiveCheck) {
+						const errorCode = fail(caught2);
+						itemStart = itemStart + (itemNextElse ? `else{${errorCode}}` : errorCode);
+					}
+				}
+				itemIdx = itemIdx + 1;
+			}
+			return itemStart + itemEnd;
+		};
+		let start = "";
+		let end = "";
+		let caught = "";
+		let exit = false;
+		const lastIdx = schemas.length - 1;
+		let byKey = {};
+		let keys = [];
+		const appendUnionRefiners = (() => {
+			const unionRefiner = selfSchema.refiner;
+			const unionInputRefiner = selfSchema.inputRefiner;
+			const cachedRefinerChecks = { contents: void 0 };
+			const cachedInputRefinerChecks = { contents: void 0 };
+			const attach = (current, source, cache) => {
+				if (source === void 0) return current;
+				else {
+					const fn = source;
+					const getCached = (input2) => {
+						if (cache.contents !== void 0) return cache.contents;
+						else {
+							const checks = fn(input2);
+							cache.contents = checks;
+							return checks;
+						}
+					};
+					if (current === void 0) return getCached;
+					else {
+						const existing = current;
+						return (input2) => {
+							const arr = existing(input2);
+							const next = getCached(input2);
+							for (let i = 0; i < next.length; i++) arr.push(next[i]);
+							return arr;
+						};
+					}
+				}
+			};
+			return (mut) => {
+				const r = attach(mut.refiner, unionRefiner, cachedRefinerChecks);
+				if (r !== void 0) mut.refiner = r;
+				const ir = attach(mut.inputRefiner, unionInputRefiner, cachedInputRefinerChecks);
+				if (ir !== void 0) mut.inputRefiner = ir;
+			};
+		})();
+		if (isLiteral(input.s)) {
+			const matching = [];
+			const rest = [];
+			for (let idx = 0; idx <= lastIdx; idx++) {
+				const schema = schemas[idx];
+				if (isLiteral(schema) && schema.const === input.s.const) matching.push(schema);
+				else rest.push(schema);
+			}
+			schemas = matching.concat(rest);
+		}
+		for (let idx = 0; idx <= lastIdx; idx++) {
+			const schema = toPerCase !== void 0 ? updateOutput(schemas[idx], (mut) => {
+				appendUnionRefiners(mut);
+				mut.to = toPerCase;
+			}) : schemas[idx];
+			const tagFlag = tagFlags[schema.type];
+			const key = unionToKey(schema);
+			if (activeKey !== "" && activeKey !== key) {} else if (flagUnsafeHas(tagFlag, tagFlagUndefined) && "fromDefault" in selfSchema) {} else {
+				const initialArr = byKey[key];
+				if (initialArr !== void 0) {
+					const arr = initialArr;
+					if (flagUnsafeHas(tagFlag, tagFlagObject) && nestedLoc in schema.properties) arr.splice(arr.length - 1, 0, schema);
+					else if (!flagUnsafeHas(tagFlag, 2096)) arr.push(schema);
+				} else {
+					const typeValidationInput = B_scope(input);
+					if (flagUnsafeHas(tagFlag, 37633)) typeValidationInput.e = unknown;
+					else {
+						const narrow = baseSchema(schema.type, false);
+						narrow.encoder = schema.encoder;
+						if (flagUnsafeHas(tagFlag, tagFlagInstance)) narrow.class = schema.class;
+						else if (flagUnsafeHas(tagFlag, tagFlagObject)) {
+							narrow.properties = immutableEmptyObject;
+							narrow.additionalItems = unknown;
+						} else if (flagUnsafeHas(tagFlag, tagFlagArray)) {
+							narrow.additionalItems = unknown;
+							narrow.items = immutableEmptyArray;
+						} else if (flagUnsafeHas(tagFlag, 2096)) narrow.const = schema.const;
+						narrow.decoder = (input2) => {
+							if (flagUnsafeHas(tagFlags[input2.s.type], tagFlagUnknown)) return B_refine(input2, input2.e, [{
+								c: (inputVar) => typeCheckCond(input2, schema, inputVar),
+								f: failInvalidType
+							}]);
+							else return schema.decoder(input2);
+						};
+						typeValidationInput.e = narrow;
+					}
+					let typeValidationOutput;
+					try {
+						typeValidationOutput = parse(typeValidationInput);
+					} catch (_) {
+						typeValidationInput.vc = void 0;
+						typeValidationOutput = typeValidationInput;
+					}
+					if (unionIsPriority(tagFlag, byKey)) keys.unshift(key);
+					else keys.push(key);
+					byKey[key] = [
+						typeValidationInput,
+						typeValidationOutput,
+						schema
+					];
+					let shouldDeopt = true;
+					let valRef = typeValidationOutput;
+					while (valRef !== void 0 && shouldDeopt) {
+						const v = valRef;
+						valRef = v.prev;
+						shouldDeopt = !(v.vc && B_isHoistable(v));
+					}
+					if (shouldDeopt) {
+						for (let keyIdx = 0; keyIdx < keys.length; keyIdx++) {
+							const key2 = keys[keyIdx];
+							if (!exit) {
+								const arr = byKey[key2];
+								const typeValidationOutput2 = arr[1];
+								const itemsCode = getArrItemsCode(arr, true);
+								const blockCode = B_merge(typeValidationOutput2) + itemsCode;
+								const embeddedError = staticBlockFailure;
+								if (embeddedError) {
+									staticBlockFailure = "";
+									if (blockCode) {
+										const errorVar = `e` + (idx + keyIdx);
+										start = start + `try{${blockCode}throw ${embeddedError}}catch(${errorVar}){`;
+										end = "}" + end;
+										caught = `${caught},${errorVar}`;
+									} else caught = `${caught},${embeddedError}`;
+								} else if (blockCode) {
+									const errorVar = `e` + (idx + keyIdx);
+									start = start + `try{${blockCode}}catch(${errorVar}){`;
+									end = "}" + end;
+									caught = `${caught},${errorVar}`;
+								} else exit = true;
+							}
+						}
+						byKey = {};
+						keys = [];
+					}
+				}
+			}
+		}
+		if (!exit) {
+			let nextElse = false;
+			let noop2 = "";
+			for (let idx = 0; idx < keys.length; idx++) {
+				const arr = byKey[keys[idx]];
+				const typeValidationOutput = arr[1];
+				const firstSchema = arr[2];
+				const itemsCode = getArrItemsCode(arr, false);
+				const blockCondRef = { contents: "" };
+				const blockCode = B_merge(typeValidationOutput, blockCondRef) + itemsCode;
+				const blockCond = blockCondRef.contents;
+				if (blockCode || unionIsPriority(tagFlags[firstSchema.type], byKey)) {
+					start = start + (nextElse ? "else if" : "if") + `(${blockCond}){${blockCode}}`;
+					nextElse = true;
+				} else noop2 = noop2 ? `${noop2}||${blockCond}` : blockCond;
+			}
+			const errorCode = fail(caught);
+			start = start + (noop2 ? (nextElse ? "else if" : "if") + `(!(${noop2})){${errorCode}}` : nextElse ? `else{${errorCode}}` : end === "" ? errorCode + ";" : errorCode);
+		}
+		output.cp = output.cp + start + end;
+		if (input.i !== output.i) output.i = input.i;
+		let o;
+		if (flagUnsafeHas(output.f, valFlagAsync)) {
+			output.i = `Promise.resolve(${output.i})`;
+			output.v = _notVar;
+			o = output;
+		} else if (output.v === _var) if (input.cp === "" && output.cp === "" && initialInline === "i") {
+			input.hd = "";
+			input.v = _notVar;
+			input.i = initialInline;
+			o = input;
+		} else o = output;
+		else o = output;
+		o.s = outputAnyOf.length ? unionFactory(outputAnyOf) : never_();
+		if (toPerCase !== void 0) {
+			o.io = true;
+			o.e = getOutputSchema(toPerCase);
+		} else o.e = selfSchema;
+		return o;
+	}
+};
+var unionFactory = (schemas) => {
+	if (schemas.length === 0) return panic("S.union requires at least one item");
+	else if (schemas.length === 1) return schemas[0];
+	else {
+		const has = {};
+		const anyOf = /* @__PURE__ */ new Set();
+		schemas.forEach((schema) => {
+			if (schema.type === unionTag && schema.to === void 0) {
+				schema.anyOf.forEach((item) => {
+					anyOf.add(item);
+				});
+				Object.assign(has, schema.has);
+			} else {
+				anyOf.add(schema);
+				setHas(has, schema.type);
+			}
+		});
+		const mut = baseSchema(unionTag, false);
+		mut.anyOf = Array.from(anyOf);
+		mut.decoder = unionDecoder;
+		mut.encoder = unionEncoder;
+		mut.has = has;
+		return mut;
+	}
+};
+var nestedNone = () => {
+	const itemSchema = Literal_parse(0);
+	const properties = {};
+	properties[nestedLoc] = itemSchema;
+	return {
+		type: objectTag,
+		required: [nestedLoc],
+		properties,
+		additionalItems: "strip",
+		decoder: objectDecoder,
+		serializer: (input) => {
+			const nextSchema = input.e.to;
+			return B_nextConst(input, nextSchema, nextSchema);
+		}
+	};
+};
+var nestedOption = (item) => {
+	return updateOutput(item, (mut) => {
+		mut.to = nestedNone();
+		mut.parser = nestedOptionParser;
+	});
+};
+var optionFactory = (item, unitSchema = unit()) => {
+	const out = getOutputSchema(item);
+	if (out.type === undefinedTag) return unionFactory([unitSchema, nestedOption(item)]);
+	else if (out.type === unionTag) {
+		const anyOf = out.anyOf;
+		const has = out.has;
+		return updateOutput(item, (mut) => {
+			const schemas = anyOf;
+			const mutHas = { ...has };
+			const newAnyOf = [];
+			for (let idx = 0; idx < schemas.length; idx++) {
+				const schema = schemas[idx];
+				let toPush;
+				const schemaOut = getOutputSchema(schema);
+				if (schemaOut.type === undefinedTag) {
+					mutHas[unitSchema.type] = true;
+					newAnyOf.push(unitSchema);
+					toPush = nestedOption(schema);
+				} else if (schemaOut.properties !== void 0) {
+					const nestedSchema = schemaOut.properties[nestedLoc];
+					if (nestedSchema !== void 0) toPush = updateOutput(schema, (mut2) => {
+						const properties2 = {};
+						properties2[nestedLoc] = {
+							...nestedSchema,
+							const: nestedSchema.const + 1
+						};
+						mut2.properties = properties2;
+					});
+					else toPush = schema;
+				} else toPush = schema;
+				newAnyOf.push(toPush);
+			}
+			if (newAnyOf.length === schemas.length) {
+				mutHas[unitSchema.type] = true;
+				newAnyOf.push(unitSchema);
+			}
+			mut.anyOf = newAnyOf;
+			mut.has = mutHas;
+		});
+	} else return unionFactory([item, unitSchema]);
+};
+var option = (item) => {
+	return optionFactory(item, unit());
+};
+var valGet = (parent, location) => {
+	let vals;
+	if (parent.d !== void 0) vals = parent.d;
+	else {
+		const d = /* @__PURE__ */ Object.create(null);
+		parent.d = d;
+		vals = d;
+	}
+	const existing = vals[location];
+	if (existing !== void 0) return B_scope(existing);
+	else {
+		let locationSchema;
+		if (parent.s.type === objectTag) locationSchema = parent.s.properties[location];
+		else locationSchema = parent.s.items[Number(location)];
+		let schema;
+		if (locationSchema !== void 0) schema = locationSchema;
+		else {
+			const additionalItems = parent.s.additionalItems;
+			if (isItemSchema(additionalItems)) {
+				const s2 = additionalItems;
+				if (parent.s.type === objectTag && s2.type !== unknownTag && !flagUnsafeHas(tagFlags[s2.type], tagFlagRef) && !isOptional(s2)) schema = option(s2);
+				else schema = s2;
+			} else schema = B_unsupportedDecode(parent, parent.s, parent.e);
+		}
+		const pathAppend = pathFromInlinedLocation(B_inlineLocation(parent.g, location));
+		const item = {
+			v: _notVarAtParent,
+			i: isLiteral(schema) ? B_inlineConst(parent, schema) : `${parent.v()}${pathAppend}`,
+			f: valFlagNone,
+			s: schema,
+			e: schema,
+			cp: "",
+			hd: "",
+			path: pathConcat(parent.path, pathAppend),
+			g: parent.g,
+			p: parent
+		};
+		vals[location] = item;
+		return item;
+	}
+};
+var recursiveDecoder = (input) => {
+	const expectedSchema = input.e;
+	const schemaRef = expectedSchema["$ref"];
+	const defs = input.g.d;
+	const def = defs[schemaRef.slice(8)];
+	const flag = input.g.o;
+	const inputSchema = input.s.seq === expectedSchema.seq ? def : input.s;
+	const key = `${inputSchema.seq}-${def.seq}--${flag}`;
+	let recOperation = "";
+	const fn = def[key];
+	if (fn !== void 0) recOperation = fn === 0 ? B_embed(input, def) + `["${key}"]` : B_embed(input, fn);
+	else {
+		let assumedHasTransform = def.hasTransform !== void 0 ? def.hasTransform : false;
+		let assumedIsAsync = def.isAsync !== void 0 ? def.isAsync : false;
+		let compileNeeded = true;
+		let finalFn = 0;
+		while (compileNeeded) {
+			compileNeeded = false;
+			if (def.hasTransform === void 0) def.hasTransform = assumedHasTransform;
+			if (def.isAsync === void 0) def.isAsync = assumedIsAsync;
+			configurableValueOptions[valKey] = 0;
+			Object.defineProperty(def, key, configurableValueOptions);
+			const fn2 = compileDecoder(inputSchema, def, flag, defs);
+			valueOptions[valKey] = fn2;
+			Object.defineProperty(def, key, valueOptions);
+			finalFn = fn2;
+			const actualHasTransform = def.hasTransform;
+			const actualIsAsync = def.isAsync;
+			if (actualHasTransform !== assumedHasTransform || actualIsAsync !== assumedIsAsync) {
+				assumedHasTransform = actualHasTransform;
+				assumedIsAsync = actualIsAsync;
+				delete def[key];
+				compileNeeded = true;
+			}
+		}
+		recOperation = B_embed(input, finalFn);
+	}
+	const hasTransform = def.hasTransform === true;
+	const isAsync2 = def.isAsync;
+	let outputDecl = "";
+	let output;
+	if (hasTransform || isAsync2) {
+		const outputVar = B_varWithoutAllocation(input.g);
+		outputDecl = `let ${outputVar};`;
+		output = B_next(input, outputVar, expectedSchema, expectedSchema);
+		output.v = _var;
+		output.cp = `${outputVar}=${recOperation}(${input.i});`;
+		if (isAsync2) output.f |= valFlagAsync;
+	} else {
+		output = B_refine(input, expectedSchema, void 0, expectedSchema);
+		output.cp = `${recOperation}(${input.i});`;
+	}
+	output.prev = void 0;
+	output.cp = outputDecl + B_mergeWithPathPrepend(output, input);
+	output.fz = void 0;
+	output.prev = input;
+	return output;
+};
+var standardJSONSchemaConverter;
+var __setStandardJSONSchemaConverter = (fn) => {
+	standardJSONSchemaConverter = fn;
+};
+var getStandardJSONSchema = (schema, options, isOutput) => {
+	if (standardJSONSchemaConverter !== void 0) return standardJSONSchemaConverter(schema, options, isOutput);
+	else throw new SuryError({
+		code: "invalid_operation",
+		path: pathEmpty,
+		reason: "~standard.jsonSchema requires S.enableStandardJSONSchema() to be called first"
+	});
+};
+Object.defineProperty(schemaPrototype, "~standard", { get: function() {
+	const schema = this;
+	return {
+		version: 1,
+		vendor,
+		validate: (input) => {
+			try {
+				return { value: getDecoder(unknown, schema)(input) };
+			} catch (exn) {
+				const error = getOrRethrow(exn);
+				return { issues: [{
+					message: error.reason,
+					path: error.path === pathEmpty ? void 0 : pathToArray(error.path)
+				}] };
+			}
+		},
+		jsonSchema: {
+			input: (options) => getStandardJSONSchema(schema, options, false),
+			output: (options) => getStandardJSONSchema(schema, options, true)
+		}
+	};
+} });
+var getAssertResult = () => {
+	return cached("a", undefinedTag, (s2) => {
+		s2.const = void 0;
+		s2.decoder = literalDecoder;
+		s2.noValidation = true;
+	});
+};
+var assertOrThrow = (any, schema) => {
+	getDecoder(unknown, schema, getAssertResult())(any);
+};
+var assertAsyncOrThrow = (any, schema) => {
+	return getDecoder(unknown, schema, getAssertResult(), flagAsync)(any);
+};
+var isAsync = (schema) => {
+	if (schema.isAsync === void 0) return isAsyncInternal(schema, void 0);
+	else return schema.isAsync;
+};
+var wrapExnToFailure = (exn) => {
+	if (exn && exn.s === s) return {
+		success: false,
+		error: exn
+	};
+	else throw exn;
+};
+var js_safe = (fn) => {
+	try {
+		return {
+			success: true,
+			value: fn()
+		};
+	} catch (exn) {
+		return wrapExnToFailure(exn);
+	}
+};
+var js_safeAsync = (fn) => {
+	try {
+		return fn().then((value) => ({
+			success: true,
+			value
+		}), wrapExnToFailure);
+	} catch (exn) {
+		return Promise.resolve(wrapExnToFailure(exn));
+	}
+};
+var Metadata_Id_make = (namespace, name) => {
+	return `m:${namespace}:${name}`;
+};
+var Metadata_Id_internal = (name) => {
+	return `m:${name}`;
+};
+var Metadata_get = (schema, id) => {
+	return schema[id];
+};
+var Metadata_setInPlace = (schema, id, metadata) => {
+	schema[id] = metadata;
+};
+var Metadata_set = (schema, id, metadata) => {
+	const mut = copySchema(schema);
+	Metadata_setInPlace(mut, id, metadata);
+	return mut;
+};
+var defsPath = `#/$defs/`;
+var recursive = (name, fn) => {
+	const ref = `${defsPath}${name}`;
+	const refSchema = baseSchema(refTag, false);
+	refSchema["$ref"] = ref;
+	refSchema.name = name;
+	refSchema.decoder = recursiveDecoder;
+	const isNestedRec = globalConfig.d !== void 0;
+	if (!isNestedRec) globalConfig.d = {};
+	const def = fn(refSchema);
+	if (def.name) refSchema.name = def.name;
+	globalConfig.d[name] = def;
+	if (isNestedRec) return refSchema;
+	else {
+		const schema = baseSchema(refTag, false);
+		schema.name = refSchema.name;
+		schema["$ref"] = ref;
+		schema["$defs"] = globalConfig.d;
+		schema.decoder = recursiveDecoder;
+		globalConfig.d = void 0;
+		return schema;
+	}
+};
+var noValidation = (schema, value) => {
+	const mut = copySchema(schema);
+	mut.noValidation = value;
+	return mut;
+};
+var internalRefine = (schema, makeRefiner) => {
+	return updateOutput(schema, (mut) => {
+		const refiner = makeRefiner(mut);
+		const existingRefiner = mut.refiner;
+		if (existingRefiner !== void 0) mut.refiner = (input) => {
+			const arr = existingRefiner(input);
+			arr.push(...refiner(input));
+			return arr;
+		};
+		else mut.refiner = refiner;
+	});
+};
+var refine = (schema, refineCheck, error, path) => {
+	const message = error !== void 0 ? error : "Refinement failed";
+	const extraPath = path !== void 0 ? pathFromArray(path) : pathEmpty;
+	return internalRefine(schema, (_) => (input) => {
+		const embeddedCheck = B_embed(input, refineCheck);
+		return [{
+			c: (inputVar) => `${embeddedCheck}(${inputVar})`,
+			f: B_invalidInputBuilder(void 0, extraPath, message)
+		}];
+	});
+};
+var getMutErrorMessage = (mut) => {
+	const em = mut.errorMessage ? { ...mut.errorMessage } : {};
+	mut.errorMessage = em;
+	return em;
+};
+var transform = (schema, transformer) => {
+	return updateOutput(schema, (mut) => {
+		mut.parser = (input) => {
+			const definition = transformer(B_effectCtx(input));
+			if (definition.p !== void 0 && definition.a === void 0) return B_embedTransformation(input, definition.p, false);
+			else if (definition.p === void 0 && definition.a !== void 0) return B_embedTransformation(input, definition.a, true);
+			else if (definition.p === void 0 && definition.a === void 0 && definition.s === void 0) return B_refine(input, void 0, void 0, input.e.to);
+			else if (definition.p === void 0 && definition.a === void 0) return B_invalidOperation(input, `The S.transform parser is missing`);
+			else return B_invalidOperation(input, `The S.transform doesn't allow parser and asyncParser at the same time. Remove parser in favor of asyncParser`);
+		};
+		const to = copySchema(unknown);
+		to.serializer = (input) => {
+			const definition = transformer(B_effectCtx(input));
+			if (definition.s !== void 0) return B_embedTransformation(input, definition.s, false);
+			else if (definition.p === void 0 && definition.a === void 0 && definition.s === void 0) return B_refine(input, void 0, void 0, input.e.to);
+			else return B_invalidOperation(input, `The S.transform serializer is missing`);
+		};
+		mut.to = to;
+		delete mut.isAsync;
+	});
+};
+var nullAsUnit = () => {
+	const schema = copySchema(nullLiteral());
+	schema.to = unit();
+	return schema;
+};
+var Option_getWithDefault = (schema, default_) => {
+	return updateOutput(schema, (mut) => {
+		const anyOf = mut.anyOf;
+		if (anyOf !== void 0) {
+			const outputItems = [];
+			const originalItems = [];
+			for (let idx = 0; idx < anyOf.length; idx++) {
+				const schema2 = anyOf[idx];
+				const outputSchema = getOutputSchema(schema2);
+				if (outputSchema.type !== undefinedTag) {
+					outputItems.push(outputSchema);
+					originalItems.push(schema2);
+				}
+			}
+			const item = outputItems.length === 0 ? panic(`Can't set default for ${toExpression(mut)}`) : outputItems.length === 1 ? outputItems[0] : unionFactory(outputItems);
+			const originalItem = originalItems.length === 1 ? originalItems[0] : unionFactory(originalItems);
+			if (default_.type === "value") {
+				const v = default_.value;
+				try {
+					getDecoder(unknown, item)(v);
+				} catch (exn) {
+					const error = getOrRethrow(exn);
+					panic(`Invalid default for ${toExpression(mut)}: ${error["message"]}`);
+				}
+				try {
+					mut.default = getDecoder(reverse(originalItem))(v);
+				} catch (_exn) {}
+			}
+			mut.parser = (input) => {
+				const nextSchema = input.e.to;
+				const inputVar = input.v();
+				return B_next(input, `${inputVar}===void 0?${default_.type === "value" ? B_inlineConst(input, Literal_parse(default_.value)) : `${B_embed(input, default_.callback)}()`}:${inputVar}`, nextSchema, nextSchema);
+			};
+			const to = copySchema(item);
+			const originalDecoder = to.decoder;
+			to.serializer = (input) => {
+				const nextSchema = reverse(originalItem);
+				return B_refine(originalDecoder(input), nextSchema, void 0, nextSchema);
+			};
+			to.decoder = noopDecoder;
+			mut.to = to;
+		} else panic(`Can't set default for ${toExpression(mut)}`);
+	});
+};
+var Option_getOr = (schema, defaultValue) => Option_getWithDefault(schema, {
+	type: "value",
+	value: defaultValue
+});
+var Option_getOrWith = (schema, defaultCb) => Option_getWithDefault(schema, {
+	type: "callback",
+	callback: defaultCb
+});
+var Object_setAdditionalItems = (schema, additionalItems, deep) => {
+	const currentAdditionalItems = schema.additionalItems;
+	if (currentAdditionalItems !== void 0 && currentAdditionalItems !== additionalItems && typeof currentAdditionalItems !== objectTag) {
+		const mut = copySchema(schema);
+		mut.additionalItems = additionalItems;
+		if (deep) {
+			const items = schema.items;
+			if (items !== void 0) mut.items = items.map((s2) => Object_setAdditionalItems(s2, additionalItems, deep));
+			const properties = schema.properties;
+			if (properties !== void 0) mut.properties = Object.fromEntries(Object.keys(properties).map((key) => [key, Object_setAdditionalItems(properties[key], additionalItems, deep)]));
+		}
+		return mut;
+	} else return schema;
+};
+var strip = (schema) => {
+	return Object_setAdditionalItems(schema, "strip", false);
+};
+var deepStrip = (schema) => {
+	return Object_setAdditionalItems(schema, "strip", true);
+};
+var strict = (schema) => {
+	return Object_setAdditionalItems(schema, "strict", false);
+};
+var deepStrict = (schema) => {
+	return Object_setAdditionalItems(schema, "strict", true);
+};
+var jsonEncoderFn = (input, target) => {
+	const toTagFlag = tagFlags[target.type];
+	if (flagUnsafeHas(toTagFlag, 46)) return parse(B_refine(input, unknown, void 0, target));
+	else if (flagUnsafeHas(toTagFlag, 2064)) {
+		const jsonExpected = copySchema(nullLiteral());
+		jsonExpected.to = target;
+		return parse(B_refine(input, unknown, void 0, jsonExpected));
+	} else if (flagUnsafeHas(toTagFlag, tagFlagArray)) {
+		const output = parse(B_refine(input, unknown, void 0, array(unknown)));
+		output.s.additionalItems = json();
+		output.e = target;
+		output.io = false;
+		return output;
+	} else if (flagUnsafeHas(toTagFlag, tagFlagObject)) {
+		const output = parse(B_refine(input, unknown, void 0, dictFactory(unknown)));
+		output.s.additionalItems = json();
+		output.e = target;
+		output.io = false;
+		return output;
+	} else if (flagUnsafeHas(toTagFlag, 768)) return input;
+	else {
+		const jsonExpected = copySchema(string());
+		jsonExpected.to = target;
+		return parse(B_refine(input, unknown, void 0, jsonExpected));
+	}
+};
+var isJsonable = (schema) => {
+	const tagFlag = tagFlags[schema.type];
+	return flagUnsafeHas(tagFlag, 46) || schema["$ref"] === json()["$ref"] || flagUnsafeHas(tagFlag, tagFlagUnion) && schema.anyOf.every(isJsonable) || flagUnsafeHas(tagFlag, tagFlagArray) && (typeof schema.additionalItems === "object" ? isJsonable(schema.additionalItems) : true) && schema.items.every(isJsonable) || flagUnsafeHas(tagFlag, tagFlagObject) && (typeof schema.additionalItems === "object" ? isJsonable(schema.additionalItems) : true) && Object.values(schema.properties).every(isJsonable);
+};
+var jsonDecoderFn = (input) => {
+	const inputTagFlag = tagFlags[input.s.type];
+	if (isJsonable(input.s)) return input;
+	else if (flagUnsafeHas(inputTagFlag, 2064)) return B_nextConst(input, nullLiteral());
+	else if (flagUnsafeHas(inputTagFlag, tagFlagArray)) {
+		const expected = baseSchema(arrayTag, false);
+		expected.items = input.s.items.map((_) => json());
+		expected.decoder = arrayDecoder;
+		expected.additionalItems = typeof input.s.additionalItems === "object" ? json() : input.s.additionalItems;
+		expected.to = input.e.to;
+		return parse(B_refine(input, void 0, void 0, expected));
+	} else if (flagUnsafeHas(inputTagFlag, tagFlagObject)) if (typeof input.s.additionalItems === "object") {
+		const expected = dictFactory(json());
+		expected.to = input.e.to;
+		return parse(B_refine(input, void 0, void 0, expected));
+	} else {
+		const jsonVal = makeObjectVal(input, input.s);
+		jsonVal.e = json();
+		if (input.e.to) {
+			jsonVal.e = copySchema(jsonVal.e);
+			jsonVal.e.to = input.e.to;
+		}
+		const keys = Object.keys(input.s.properties);
+		for (let idx = 0; idx <= keys.length - 1; idx++) {
+			const key = keys[idx];
+			const itemVal = valGet(input, key);
+			itemVal.io = false;
+			if (itemVal.s.type === unionTag && itemVal.s.has[undefinedTag]) {
+				itemVal.e = unionFactory([unit(), json()]);
+				const itemOutput = parse(itemVal);
+				itemOutput.o = true;
+				B_addObjectField(jsonVal, key, itemOutput);
+			} else {
+				itemVal.e = json();
+				B_addObjectField(jsonVal, key, parse(itemVal));
+			}
+		}
+		return completeObjectVal(jsonVal);
+	}
+	else if (flagUnsafeHas(inputTagFlag, tagFlagRef)) return recursiveDecoder(input);
+	else if (flagUnsafeHas(inputTagFlag, tagFlagUnion) && !(undefinedTag in input.s.has)) return parse(unionPerVariantVal(input, input.e));
+	else if (flagUnsafeHas(inputTagFlag, tagFlagUnknown)) if (!!input.e.to && !input.e.parser) {
+		input.s = json();
+		return jsonEncoderFn(input, input.e);
+	} else if (input.e.noValidation) {
+		input.s = json();
+		return input;
+	} else return recursiveDecoder(input);
+	else try {
+		const expected = copySchema(string());
+		expected.to = input.e;
+		input.e = expected;
+		return parse(input);
+	} catch {
+		return B_unsupportedDecode(input, input.s, json());
+	}
+};
+var json = () => {
+	return cached(jsonName, refTag, (s2) => {
+		const jsonRef = baseSchema(refTag, true);
+		jsonRef["$ref"] = `${defsPath}${jsonName}`;
+		jsonRef.name = jsonName;
+		jsonRef.decoder = jsonDecoderFn;
+		const jsonEncoder = jsonEncoderFn;
+		jsonRef.encoder = jsonEncoder;
+		s2["$ref"] = jsonRef["$ref"];
+		s2.name = jsonName;
+		s2.decoder = jsonDecoderFn;
+		s2.encoder = jsonEncoder;
+		const anyOf = [
+			string(),
+			bool(),
+			float(),
+			nullLiteral(),
+			dictFactory(jsonRef),
+			array(jsonRef)
+		];
+		const has = {};
+		anyOf.forEach((schema) => {
+			has[schema.type] = true;
+		});
+		const jsonDef = baseSchema(unionTag, true);
+		jsonDef.anyOf = anyOf;
+		jsonDef.has = has;
+		jsonDef.decoder = unionDecoder;
+		jsonDef.name = jsonName;
+		jsonDef.type = unionTag;
+		const defs = {};
+		defs[jsonName] = jsonDef;
+		s2["$defs"] = defs;
+	});
+};
+var jsonString = /* @__PURE__ */ (() => {
+	const inlineJsonString = (input, schema) => {
+		const tagFlag = tagFlags[schema.type];
+		const const_ = schema.const;
+		if (flagUnsafeHas(tagFlag, 48)) return `"null"`;
+		else if (flagUnsafeHas(tagFlag, tagFlagString)) return JSON.stringify(inlinedValueFromString(const_));
+		else if (flagUnsafeHas(tagFlag, tagFlagBigint)) return `"\\"${const_}\\""`;
+		else if (flagUnsafeHas(tagFlag, 12)) return `"${const_}"`;
+		else return B_unsupportedDecode(input, schema, input.e);
+	};
+	const constSchemaToJsonStringConst = (input, target) => {
+		const tagFlag = tagFlags[target.type];
+		const const_ = target.const;
+		if (flagUnsafeHas(tagFlag, 48)) return `null`;
+		else if (flagUnsafeHas(tagFlag, tagFlagString)) return inlinedValueFromString(const_);
+		else if (flagUnsafeHas(tagFlag, tagFlagBigint)) return `"${const_}"`;
+		else if (flagUnsafeHas(tagFlag, 12)) return "" + const_;
+		else return B_unsupportedDecode(input, input.s, target);
+	};
+	const jsonStringEncoder = (input, target) => {
+		if (target.format !== "json") if (isLiteral(target)) {
+			const jsonStringConstSchema = baseSchema(stringTag, true);
+			jsonStringConstSchema.const = constSchemaToJsonStringConst(input, target);
+			jsonStringConstSchema.to = target;
+			jsonStringConstSchema.decoder = literalDecoder;
+			return B_refine(input, void 0, void 0, jsonStringConstSchema);
+		} else {
+			const outputVar = B_varWithoutAllocation(input.g);
+			const nextSchema = copySchema(json());
+			nextSchema.to = target;
+			const output = B_next(input, outputVar, nextSchema, nextSchema);
+			output.io = true;
+			output.v = _var;
+			output.cp = `let ${outputVar};try{${outputVar}=JSON.parse(${input.v()})}catch(t){${B_embedInvalidInput(input, input.s)}}`;
+			return output;
+		}
+		else return input;
+	};
+	const jsonStringDecoder = (input) => {
+		const inputTagFlag = tagFlags[input.s.type];
+		const expectedSchema = input.e;
+		if (flagUnsafeHas(inputTagFlag, tagFlagUnknown)) {
+			const to = expectedSchema.to;
+			const preEncode = !!to && to.type !== unknownTag && !expectedSchema.parser && !expectedSchema.refiner;
+			const stringVal = stringDecoderFn(input);
+			stringVal.s = expectedSchema;
+			stringVal.e = expectedSchema;
+			if (preEncode) return jsonStringEncoder(stringVal, to);
+			else {
+				const stringVar = stringVal.v();
+				const output = B_refine(stringVal, expectedSchema);
+				output.cp = `try{JSON.parse(${stringVar})}catch(t){${B_embedInvalidInput(stringVal)}}`;
+				return output;
+			}
+		} else if (input.s.format === "json") return input;
+		else if (isLiteral(input.s)) return B_next(input, inlineJsonString(input, input.s), expectedSchema);
+		else if (flagUnsafeHas(inputTagFlag, tagFlagString)) return B_next(input, `JSON.stringify(${input.i})`, expectedSchema);
+		else if (flagUnsafeHas(inputTagFlag, 12)) {
+			const output = inputToString(input);
+			output.s = expectedSchema;
+			return output;
+		} else if (flagUnsafeHas(inputTagFlag, tagFlagBigint)) return B_next(input, `"\\""+${input.i}+"\\""`, expectedSchema);
+		else if (flagUnsafeHas(inputTagFlag, 192)) {
+			const jsonVal = parse(B_refine(input, void 0, void 0, json()));
+			return B_next(jsonVal, `JSON.stringify(${jsonVal.i}${expectedSchema.space === 0 || expectedSchema.space === void 0 ? "" : `,null,${expectedSchema.space}`})`, expectedSchema, expectedSchema);
+		} else return B_unsupportedDecode(input, input.s, expectedSchema);
+	};
+	return () => cached("json", stringTag, (s2) => {
+		s2.format = "json";
+		s2.name = `${jsonName} string`;
+		s2.encoder = jsonStringEncoder;
+		s2.decoder = jsonStringDecoder;
+	});
+})();
+var jsonStringWithSpace = (space) => {
+	const mut = copySchema(jsonString());
+	mut.space = space;
+	return mut;
+};
+var uint8Array = () => {
+	return cached("u", instanceTag, (s2) => {
+		s2.class = Uint8Array;
+		s2.decoder = (inputArg) => {
+			const inputTagFlag = tagFlags[inputArg.s.type];
+			let input = inputArg;
+			if (flagUnsafeHas(inputTagFlag, tagFlagString)) input = B_next(input, `${B_embed(input, new TextEncoder())}.encode(${input.i})`, s2);
+			else if (flagUnsafeHas(inputTagFlag, 8193)) input = instanceDecoder(input);
+			if (inputArg.e.to !== void 0 && inputArg.e.parser === void 0) {
+				const toTagFlag = tagFlags[inputArg.e.to.type];
+				if (flagUnsafeHas(toTagFlag, tagFlagString)) input = B_next(input, `${B_embed(input, new TextDecoder())}.decode(${input.i})`, string());
+				return input;
+			} else return input;
+		};
+	});
+};
+var isoDateTime = () => {
+	return cached("date-time", stringTag, (s2) => {
+		const datetimeRe = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
+		s2.decoder = stringDecoderFn;
+		s2.format = "date-time";
+		s2.refiner = (input) => {
+			return [{
+				c: (inputVar) => `${B_embed(input, datetimeRe)}.test(${inputVar})`,
+				f: B_failWithErrorMessage("format", "Invalid datetime string! Expected UTC")
+			}];
+		};
+	});
+};
+var port = () => {
+	return cached("port", numberTag, (s2) => {
+		s2.decoder = numberDecoder;
+		s2.format = "port";
+		s2.refiner = (_input) => {
+			return [{
+				c: (inputVar) => `${inputVar}>0&&${inputVar}<65536&&${inputVar}%1===0`,
+				f: B_failWithErrorMessage("format")
+			}];
+		};
+	});
+};
+var email = () => {
+	return cached("email", stringTag, (s2) => {
+		const emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
+		s2.decoder = stringDecoderFn;
+		s2.format = "email";
+		s2.refiner = (input) => {
+			return [{
+				c: (inputVar) => `${B_embed(input, emailRegex)}.test(${inputVar})`,
+				f: B_failWithErrorMessage("format")
+			}];
+		};
+	});
+};
+var uuid = () => {
+	return cached("uuid", stringTag, (s2) => {
+		const uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
+		s2.decoder = stringDecoderFn;
+		s2.format = "uuid";
+		s2.refiner = (input) => {
+			return [{
+				c: (inputVar) => `${B_embed(input, uuidRegex)}.test(${inputVar})`,
+				f: B_failWithErrorMessage("format")
+			}];
+		};
+	});
+};
+var cuid = () => {
+	return cached("cuid", stringTag, (s2) => {
+		const cuidRegex = /^c[^\s-]{8,}$/i;
+		s2.decoder = stringDecoderFn;
+		s2.format = "cuid";
+		s2.refiner = (input) => {
+			return [{
+				c: (inputVar) => `${B_embed(input, cuidRegex)}.test(${inputVar})`,
+				f: B_failWithErrorMessage("format")
+			}];
+		};
+	});
+};
+var url = () => {
+	return cached("url", stringTag, (s2) => {
+		const urlValidator = (s3) => {
+			try {
+				new URL(s3);
+				return true;
+			} catch {
+				return false;
+			}
+		};
+		s2.decoder = stringDecoderFn;
+		s2.format = "url";
+		s2.refiner = (input) => {
+			return [{
+				c: (inputVar) => `${B_embed(input, urlValidator)}(${inputVar})`,
+				f: B_failWithErrorMessage("format")
+			}];
+		};
+	});
+};
+var invalidDateRefine = (input) => {
+	return B_refine(input, input.e, [{
+		c: (inputVar) => `!Number.isNaN(${inputVar}.getTime())`,
+		f: failInvalidType
+	}]);
+};
+var date = () => {
+	return cached(instanceTag, instanceTag, (s2) => {
+		s2.class = Date;
+		s2.decoder = (input) => {
+			const inputTagFlag = tagFlags[input.s.type];
+			if (flagUnsafeHas(inputTagFlag, tagFlagString)) return invalidDateRefine(B_next(input, `new Date(${input.i})`, s2));
+			else if (flagUnsafeHas(inputTagFlag, tagFlagUnknown)) return invalidDateRefine(instanceDecoder(input));
+			else if (flagUnsafeHas(inputTagFlag, tagFlagInstance) && input.s.class === s2.class) return input;
+			else return B_unsupportedDecode(input, input.s, input.e);
+		};
+		s2.encoder = (input, target) => {
+			const toTagFlag = tagFlags[target.type];
+			if (flagUnsafeHas(toTagFlag, tagFlagString)) {
+				const dateTimeString = baseSchema(stringTag, false);
+				dateTimeString.format = "date-time";
+				return parse(B_next(input, `${input.i}.toISOString()`, dateTimeString, target));
+			} else return input;
+		};
+	});
+};
+var listFromArray = (array2) => {
+	let list2 = 0;
+	for (let i = array2.length - 1; i >= 0; i--) list2 = {
+		hd: array2[i],
+		tl: list2
+	};
+	return list2;
+};
+var listToArray = (list2) => {
+	const array2 = [];
+	let current = list2;
+	while (current !== 0) {
+		array2.push(current.hd);
+		current = current.tl;
+	}
+	return array2;
+};
+var list = (schema) => {
+	return transform(array(schema), (_) => ({
+		p: (array2) => listFromArray(array2),
+		s: (list2) => listToArray(list2)
+	}));
+};
+var meta = (schema, data) => {
+	const mut = copySchema(schema);
+	if (data.name !== void 0) if (data.name === "") mut.name = void 0;
+	else mut.name = data.name;
+	if (data.title !== void 0) if (data.title === "") mut.title = void 0;
+	else mut.title = data.title;
+	if (data.description !== void 0) if (data.description === "") mut.description = void 0;
+	else mut.description = data.description;
+	if (data.deprecated !== void 0) mut.deprecated = data.deprecated;
+	if (data.examples !== void 0) if (data.examples.length === 0) delete mut.examples;
+	else mut.examples = data.examples.map(getDecoder(reverse(schema)));
+	if (data.errorMessage !== void 0) {
+		const em = data.errorMessage;
+		if (Object.keys(em).length === 0) mut.errorMessage = void 0;
+		else mut.errorMessage = em;
+	}
+	return mut;
+};
+var brand = (schema, id) => {
+	const mut = copySchema(schema);
+	mut.name = id;
+	return mut;
+};
+var inputFrom = immutableEmptyArray;
+var makeTag = (field) => (tag, asValue) => {
+	field(tag, definitionToSchema(asValue));
+};
+var makeFieldOr = (field) => (fieldName, schema, or) => {
+	return field(fieldName, Option_getOr(optionFactory(schema), or));
+};
+var proxifyShapedSchema = (schema, from, fromFlattened) => {
+	const mut = copySchema(getOutputSchema(schema));
+	mut.from = from;
+	if (fromFlattened !== void 0) mut.fromFlattened = fromFlattened;
+	return new Proxy(mut, { get(target, prop) {
+		if (prop === itemSymbol) return target;
+		else {
+			const location = prop;
+			let maybeField;
+			if (target.properties !== void 0) maybeField = target.properties[location];
+			else if (target.items !== void 0) maybeField = target.items[location];
+			else maybeField = void 0;
+			if (maybeField === void 0) panic(`Cannot read property "${location}" of ${toExpression(target)}`);
+			return proxifyShapedSchema(maybeField, target.from.concat(location), target.fromFlattened);
+		}
+	} });
+};
+var schemaShape = (schema, definer) => {
+	return updateOutput(schema, (mut) => {
+		const fromProxy = proxifyShapedSchema(mut, inputFrom);
+		const definition = definer(fromProxy);
+		if (definition === fromProxy) {} else {
+			mut.parser = shapedParser;
+			mut.to = definitionToShapedSchema(definition);
+		}
+	});
+};
+function schemaNested(fieldName) {
+	const parentCtx = this;
+	const cacheId = `~${fieldName}`;
+	const cachedCtx = parentCtx[cacheId];
+	if (cachedCtx !== void 0) return cachedCtx;
+	else {
+		const properties = /* @__PURE__ */ Object.create(null);
+		const required = [];
+		let schema;
+		{
+			const s2 = baseSchema(objectTag, false);
+			s2.required = required;
+			s2.properties = properties;
+			s2.additionalItems = globalConfig.a;
+			s2.decoder = objectDecoder;
+			schema = s2;
+		}
+		const parentSchema = parentCtx.f(fieldName, schema)[itemSymbol];
+		const field = (fieldName2, schema2) => {
+			const inlinedLocation = inlinedValueFromString(fieldName2);
+			if (fieldName2 in properties) panic(`The field ${inlinedLocation} defined twice`);
+			required.push(fieldName2);
+			properties[fieldName2] = schema2;
+			return proxifyShapedSchema(schema2, parentSchema.from.concat(fieldName2), parentSchema.fromFlattened);
+		};
+		const tag = makeTag(field);
+		const fieldOr = makeFieldOr(field);
+		const flatten = (schema2) => {
+			if (schema2.type === objectTag) {
+				const flattenedProperties = schema2.properties;
+				if (schema2.to) panic(`Unsupported nested flatten for transformed object schema ${toExpression(schema2)}`);
+				const flattenedKeys = Object.keys(flattenedProperties);
+				const result = {};
+				for (let idx = 0; idx < flattenedKeys.length; idx++) {
+					const key = flattenedKeys[idx];
+					result[key] = field(key, flattenedProperties[key]);
+				}
+				return result;
+			} else return panic(`Can't flatten ${toExpression(schema2)} schema`);
+		};
+		const ctx = {
+			field,
+			f: field,
+			fieldOr,
+			tag,
+			nested: schemaNested,
+			flatten
+		};
+		parentCtx[cacheId] = ctx;
+		return ctx;
+	}
+}
+var schemaObject = (definer) => {
+	if (typeof definer !== "function") return definitionToSchema(definer);
+	let flattened = void 0;
+	const properties = /* @__PURE__ */ Object.create(null);
+	const flatten = (schema) => {
+		if (schema.type === objectTag) {
+			const flattenedProperties = schema.properties;
+			const flattenedKeys = Object.keys(flattenedProperties);
+			for (let idx = 0; idx < flattenedKeys.length; idx++) {
+				const key = flattenedKeys[idx];
+				const flattenedSchema = flattenedProperties[key];
+				const existing = properties[key];
+				if (existing !== void 0 && existing === flattenedSchema) {} else if (existing !== void 0) panic(`The field "${key}" defined twice with incompatible schemas`);
+				else properties[key] = flattenedSchema;
+			}
+			return proxifyShapedSchema(schema, inputFrom, (flattened || (flattened = [])).push(schema) - 1);
+		} else return panic(`The '${toExpression(schema)}' schema can't be flattened`);
+	};
+	const field = (fieldName, schema) => {
+		if (fieldName in properties) panic(`The field "${fieldName}" defined twice with incompatible schemas`);
+		properties[fieldName] = schema;
+		return proxifyShapedSchema(schema, [fieldName]);
+	};
+	const tag = makeTag(field);
+	const definition = definer({
+		field,
+		f: field,
+		fieldOr: makeFieldOr(field),
+		tag,
+		nested: schemaNested,
+		flatten
+	});
+	const mut = baseSchema(objectTag, false);
+	mut.required = Object.keys(properties);
+	mut.properties = properties;
+	mut.additionalItems = globalConfig.a;
+	mut.decoder = objectDecoder;
+	mut.parser = shapedParser;
+	mut.to = definitionToShapedSchema(definition);
+	if (flattened !== void 0) mut.flattened = flattened;
+	return mut;
+};
+var schemaTuple = (definer) => {
+	if (typeof definer !== "function") return definitionToSchema(definer);
+	const items = [];
+	const item = (idx, schema) => {
+		const location = String(idx);
+		if (items[idx]) return panic(`The item [${location}] is defined multiple times`);
+		else {
+			items[idx] = schema;
+			return proxifyShapedSchema(schema, [location]);
+		}
+	};
+	const tag = (idx, asValue) => {
+		item(idx, definitionToSchema(asValue));
+	};
+	const definition = definer({
+		item,
+		tag
+	});
+	for (let idx = 0; idx < items.length; idx++) if (!items[idx]) items[idx] = unit();
+	const mut = baseSchema(arrayTag, false);
+	mut.items = items;
+	mut.additionalItems = "strict";
+	mut.decoder = arrayDecoder;
+	mut.parser = shapedParser;
+	mut.to = definitionToShapedSchema(definition);
+	return mut;
+};
+var getValByFrom = (input, from, idx) => {
+	const key = from[idx];
+	if (key !== void 0) return getValByFrom(input.d[key], from, idx + 1);
+	else return input;
+};
+var assembleShapedObject = (input, schema, field, init, onMissing) => {
+	const output = makeObjectVal(input, schema);
+	output.io = true;
+	if (init !== void 0) init(output);
+	if (schema.items !== void 0) {
+		const items = schema.items;
+		for (let idx = 0; idx < items.length; idx++) {
+			const location = String(idx);
+			B_addObjectField(output, location, field(location, items[idx]));
+		}
+	} else if (schema.properties !== void 0) {
+		const properties = schema.properties;
+		const keys = Object.keys(properties);
+		for (let idx = 0; idx < keys.length; idx++) {
+			const location = keys[idx];
+			if (!(location in output.d)) B_addObjectField(output, location, field(location, properties[location]));
+		}
+	} else if (onMissing !== void 0) onMissing();
+	else panic(`Don't know where the value is coming from: ${toExpression(schema)}` + (input.path === "" ? "" : ` at ${input.path}`));
+	return completeObjectVal(output);
+};
+var getShapedParserOutput = (input, targetSchema) => {
+	let v;
+	if (targetSchema.fromFlattened !== void 0) v = B_scope(getValByFrom(input.fv[targetSchema.fromFlattened], targetSchema.from, 0));
+	else if (targetSchema.from !== void 0) v = B_scope(getValByFrom(input, targetSchema.from, 0));
+	else if (isLiteral(targetSchema)) v = B_nextConst(input, targetSchema);
+	else v = assembleShapedObject(input, targetSchema, (_location, childSchema) => getShapedParserOutput(input, childSchema));
+	v.prev = void 0;
+	v.e = targetSchema;
+	return v;
+};
+var shapedParser = (input) => {
+	const flattened = input.e.flattened;
+	if (flattened !== void 0) {
+		const flattenedVals = [];
+		for (let idx = 0; idx < flattened.length; idx++) {
+			const flattenedSchema = flattened[idx];
+			let flattenedVal;
+			if (flattenedSchema.to !== void 0) {
+				const flattenedInput = B_scope(input);
+				flattenedInput.e = flattenedSchema;
+				flattenedInput.io = true;
+				flattenedVal = parse(flattenedInput);
+			} else {
+				const assembled = assembleShapedObject(input, flattenedSchema, (location, _childSchema) => valGet(input, location));
+				assembled.e = flattenedSchema;
+				assembled.prev = void 0;
+				flattenedVal = B_markOutput(assembled, assembled);
+			}
+			flattenedVals.push(flattenedVal);
+			input.cp = input.cp + B_merge(flattenedVal);
+		}
+		input.fv = flattenedVals;
+	}
+	const targetSchema = input.e.to;
+	const output = getShapedParserOutput(input, targetSchema);
+	output.t = true;
+	output.prev = input;
+	return B_markOutput(output, input);
+};
+var prepareShapedSerializerAcc = (acc, input) => {
+	if (input.e.from !== void 0) {
+		const from = input.e.from;
+		const fromFlattened = input.e.fromFlattened;
+		let accAtFrom;
+		if (fromFlattened !== void 0) {
+			if (acc.flattened === void 0) acc.flattened = [];
+			const existing = acc.flattened[fromFlattened];
+			if (existing === void 0) {
+				const newAcc = {};
+				acc.flattened[fromFlattened] = newAcc;
+				accAtFrom = newAcc;
+			} else accAtFrom = existing;
+		} else accAtFrom = acc;
+		for (let idx = 0; idx < from.length; idx++) {
+			const key = from[idx];
+			let p;
+			if (accAtFrom.properties !== void 0) p = accAtFrom.properties;
+			else {
+				p = {};
+				accAtFrom.properties = p;
+			}
+			const existingAcc = p[key];
+			if (existingAcc !== void 0) accAtFrom = existingAcc;
+			else {
+				const newAcc = {};
+				p[key] = newAcc;
+				accAtFrom = newAcc;
+			}
+		}
+		accAtFrom.val = input;
+	} else if (input.d !== void 0) {
+		const vals = input.d;
+		const keys = Object.keys(vals);
+		for (let idx = 0; idx < keys.length; idx++) prepareShapedSerializerAcc(acc, vals[keys[idx]]);
+	}
+};
+var getShapedSerializerOutput = (input, acc, targetSchema, path) => {
+	if (acc !== void 0 && acc.val !== void 0) {
+		const v = B_scope(acc.val);
+		v.t = true;
+		v.e = targetSchema;
+		return parse(v);
+	} else if (isLiteral(targetSchema)) {
+		const v = B_nextConst(input, targetSchema, targetSchema);
+		v.prev = void 0;
+		v.p = input;
+		v.v = _notVarAtParent;
+		v.io = true;
+		return parse(v);
+	} else {
+		const resolvedTargetSchema = acc === void 0 ? getOutputSchema(targetSchema) : targetSchema;
+		const missingInput = () => {
+			const path2 = targetSchema.from !== void 0 ? path + targetSchema.from.map((item) => `["${item}"]`).join("") : path;
+			return B_invalidOperation(input, `Missing input for ${toExpression(targetSchema)}` + (path2 === "" ? "" : ` at ${path2}`));
+		};
+		if (acc === void 0 && typeof resolvedTargetSchema.additionalItems === objectTag) return missingInput();
+		return assembleShapedObject(input, resolvedTargetSchema, (location, childSchema) => getShapedSerializerOutput(input, acc !== void 0 && acc.properties !== void 0 ? acc.properties[location] : void 0, childSchema, pathConcat(path, pathFromInlinedLocation(B_inlineLocation(input.g, location)))), (v) => {
+			v.e = resolvedTargetSchema;
+			v.prev = void 0;
+			v.p = input;
+			v.v = _notVarAtParent;
+			const flattened = resolvedTargetSchema.flattened;
+			if (flattened !== void 0 && acc !== void 0 && acc.flattened !== void 0) {
+				const flattenedSchemas = flattened;
+				acc.flattened.forEach((acc2, idx) => {
+					B_mergeObjectFields(v, getShapedSerializerOutput(input, acc2, reverse(flattenedSchemas[idx]), path).d);
+				});
+			}
+		}, missingInput);
+	}
+};
+var shapedSerializer = (input) => {
+	const acc = {};
+	prepareShapedSerializerAcc(acc, input);
+	const targetSchema = input.e.to;
+	const output = getShapedSerializerOutput(input, acc, targetSchema, pathEmpty);
+	output.t = true;
+	output.prev = input;
+	return output;
+};
+var definitionToShapedSchema = (definition) => {
+	const s2 = copySchema(traverseDefinition(definition, (definition2) => definition2[itemSymbol]));
+	s2.serializer = shapedSerializer;
+	return s2;
+};
+var definitionToSchema = (definition) => {
+	return traverseDefinition(definition, (node) => {
+		if (isSchemaObject(node)) return node;
+		else return;
+	});
+};
+var traverseDefinition = (definition, onNode) => {
+	if (typeof definition === objectTag && definition !== null) {
+		const s2 = onNode(definition);
+		if (s2 !== void 0) return s2;
+		else if (Array.isArray(definition)) {
+			const node = definition;
+			for (let idx = 0; idx < node.length; idx++) node[idx] = traverseDefinition(node[idx], onNode);
+			const items = node;
+			const mut = baseSchema(arrayTag, false);
+			mut.items = items;
+			mut.additionalItems = "strict";
+			mut.decoder = arrayDecoder;
+			return mut;
+		} else {
+			const proto = Object.getPrototypeOf(definition);
+			if (proto !== null && proto !== Object.prototype) {
+				const mut = baseSchema(instanceTag, true);
+				mut.class = definition["constructor"];
+				mut.const = definition;
+				mut.decoder = literalDecoder;
+				return mut;
+			} else {
+				const node = definition;
+				const fieldNames = Object.keys(node);
+				const length2 = fieldNames.length;
+				for (let idx = 0; idx < length2; idx++) {
+					const location = fieldNames[idx];
+					node[location] = traverseDefinition(node[location], onNode);
+				}
+				const mut = baseSchema(objectTag, false);
+				mut.required = fieldNames;
+				mut.properties = node;
+				mut.additionalItems = globalConfig.a;
+				mut.decoder = objectDecoder;
+				return mut;
+			}
+		}
+	} else return Literal_parse(definition);
+};
+var schemaCtx = { m: (schema) => schema };
+var schemaDefiner = (definer) => {
+	return definitionToSchema(definer(schemaCtx));
+};
+var schemaFactory = (definition) => {
+	return definitionToSchema(definition);
+};
+var enum_ = (values) => {
+	return unionFactory(values.map(schemaFactory));
+};
+var js_parser = (...args) => getDecoder(unknown, ...args);
+var js_asyncParser = (...args) => getDecoder(unknown, ...args, 1);
+var js_asyncDecoder = (...args) => getDecoder(...args, 1);
+var js_encoder = (...args) => getDecoder(...args.map(reverse));
+var js_asyncEncoder = (...args) => getDecoder(...args.map(reverse), 1);
+var js_assert = (a, b) => {
+	const aIsSchema = !!a && isSchemaObject(a);
+	const schema = aIsSchema ? a : b;
+	const data = aIsSchema ? b : a;
+	return getDecoder(unknown, schema, getAssertResult())(data);
+};
+var js_is = (a, b) => {
+	try {
+		js_assert(a, b);
+		return true;
+	} catch (exn) {
+		getOrRethrow(exn);
+		return false;
+	}
+};
+var js_union = (values) => unionFactory(values.map(definitionToSchema));
+var js_to = /* @__PURE__ */ (() => {
+	const customBuilder = (fn) => {
+		return (input) => {
+			const target = input.e.to;
+			const outputVar = B_varWithoutAllocation(input.g);
+			const output = B_next(input, outputVar, target, target);
+			output.v = _var;
+			output.cp = `let ${outputVar};try{${output.i}=${B_embed(input, fn)}(${input.i})}catch(x){${B_failWithArg(output, (e) => B_makeInvalidConversionDetails(input, target, e), `x`)}}`;
+			return output;
+		};
+	};
+	return (schema, target, maybeDecoder, maybeEncoder) => {
+		return updateOutput(schema, (mut) => {
+			if (maybeEncoder !== void 0) {
+				const targetMut = copySchema(target);
+				targetMut.serializer = customBuilder(maybeEncoder);
+				mut.to = targetMut;
+			} else mut.to = target;
+			if (maybeDecoder !== void 0) mut.parser = customBuilder(maybeDecoder);
+		});
+	};
+})();
+var js_refine = (schema, refineCheck, refineOptions) => {
+	const message = refineOptions?.error ?? "Refinement failed";
+	const extraPath = refineOptions?.path !== void 0 ? pathFromArray(refineOptions.path) : pathEmpty;
+	return internalRefine(schema, (_) => (input) => {
+		const embeddedCheck = B_embed(input, refineCheck);
+		return [{
+			c: (inputVar) => `${embeddedCheck}(${inputVar})`,
+			f: B_invalidInputBuilder(void 0, extraPath, message)
+		}];
+	});
+};
+var noop = (a) => a;
+var js_asyncDecoderAssert = (schema, assertFn) => {
+	return transform(schema, (_) => {
+		return {
+			a: (v) => assertFn(v).then(() => v),
+			s: noop
+		};
+	});
+};
+var js_optional = (schema, maybeOr) => {
+	schema = unionFactory([schema, unit()]);
+	if (maybeOr !== void 0 && typeof maybeOr === functionTag) return Option_getOrWith(schema, maybeOr);
+	else if (maybeOr !== void 0) return Option_getOr(schema, maybeOr);
+	else return schema;
+};
+var js_nullable = (schema, maybeOr) => {
+	if (maybeOr !== void 0) {
+		const schema2 = unionFactory([schema, nullAsUnit()]);
+		if (typeof maybeOr === functionTag) return Option_getOrWith(schema2, maybeOr);
+		else return Option_getOr(schema2, maybeOr);
+	} else return unionFactory([schema, nullLiteral()]);
+};
+var js_merge = (s1, s2) => {
+	let result;
+	if (s1.type === objectTag && s2.type === objectTag && typeof s1.additionalItems === stringTag && typeof s2.additionalItems === stringTag && !s1.to && !s2.to) {
+		const properties = {
+			...s1.properties,
+			...s2.properties
+		};
+		const mut = baseSchema(objectTag, false);
+		mut.required = Object.keys(properties);
+		mut.properties = properties;
+		mut.additionalItems = s1.additionalItems;
+		mut.decoder = objectDecoder;
+		result = mut;
+	}
+	if (result !== void 0) return result;
+	else return panic("The merge supports only structured object schemas without transformations");
+};
+var global = (override) => {
+	globalConfig.a = override.defaultAdditionalItems !== void 0 ? override.defaultAdditionalItems : initialOnAdditionalItems;
+	globalConfig.f = override.disableNanNumberValidation === true ? flagDisableNanNumberValidation : initialDefaultFlag;
+};
+var compactColumnsDecoder = (input) => {
+	const selfSchema = input.e;
+	const isUnknownInput = flagUnsafeHas(tagFlags[input.s.type], tagFlagUnknown);
+	const declaredItemSchema = selfSchema.additionalItems.additionalItems;
+	let forwardProps;
+	if (selfSchema.to !== void 0 && typeof selfSchema.to.additionalItems === "object") forwardProps = selfSchema.to.additionalItems.properties;
+	else forwardProps = void 0;
+	const isForwardDirection = forwardProps !== void 0;
+	let maybeProperties;
+	if (isForwardDirection) maybeProperties = forwardProps;
+	else if (input.s.additionalItems !== void 0 && typeof input.s.additionalItems === "object") maybeProperties = input.s.additionalItems.properties;
+	else maybeProperties = void 0;
+	if (maybeProperties === void 0) return panic("S.compactColumns supports only object schemas. Use S.compactColumns(S.unknown)->S.to(S.array(objectSchema)).");
+	else {
+		const properties = maybeProperties;
+		const keys = Object.keys(properties);
+		const keysLen = keys.length;
+		let outputSchema;
+		if (isForwardDirection) outputSchema = selfSchema.to;
+		else {
+			const s2 = array(array(unknown));
+			s2.to = selfSchema.to;
+			outputSchema = s2;
+		}
+		if (keysLen === 0) {
+			if (isUnknownInput) input = B_refine(input, void 0, [{
+				c: (inputVar) => `Array.isArray(${inputVar})&&${inputVar}.length===0`,
+				f: failInvalidType
+			}]);
+			return B_markOutput(B_next(input, "[]", outputSchema, outputSchema), input);
+		} else if (isForwardDirection) {
+			if (isUnknownInput) input = B_refine(input, void 0, [{
+				c: (inputVar2) => {
+					let check = `Array.isArray(${inputVar2})&&${inputVar2}.length===${keysLen}`;
+					for (let idx = 0; idx <= keysLen - 1; ++idx) check = check + `&&Array.isArray(${inputVar2}[${idx}])`;
+					return check;
+				},
+				f: failInvalidType
+			}]);
+			const inputVar = input.v();
+			const iteratorVar = B_varWithoutAllocation(input.g);
+			const outputVar = B_varWithoutAllocation(input.g);
+			let runtimeItemSchema;
+			if (isUnknownInput) runtimeItemSchema = unknown;
+			else runtimeItemSchema = input.s.additionalItems.additionalItems;
+			let lengthCode = "";
+			let itemBuildCode = "";
+			let itemParseCode = "";
+			let asyncInlines = "";
+			let hasAsync = false;
+			for (let idx = 0; idx <= keysLen - 1; ++idx) {
+				const key = keys[idx];
+				const idxStr = `${idx}`;
+				const rawValueCode = `${inputVar}[${idxStr}][${iteratorVar}]`;
+				const fieldSchema = properties[key];
+				let itemExpected;
+				if (declaredItemSchema !== runtimeItemSchema) {
+					const chained = copySchema(declaredItemSchema);
+					chained.to = fieldSchema;
+					itemExpected = chained;
+				} else itemExpected = fieldSchema;
+				const itemInput = B_scope(input);
+				itemInput.i = rawValueCode;
+				itemInput.s = runtimeItemSchema;
+				itemInput.e = itemExpected;
+				itemInput.v = _notVarBeforeValidation;
+				itemInput.io = false;
+				itemInput.path = pathFromInlinedLocation(B_inlineLocation(input.g, key));
+				const itemOutput = parse(itemInput);
+				if (flagUnsafeHas(itemOutput.f, valFlagAsync)) hasAsync = true;
+				itemParseCode = itemParseCode + B_merge(itemOutput);
+				lengthCode = lengthCode + `${inputVar}[${idxStr}].length,`;
+				asyncInlines = asyncInlines + `${itemOutput.i},`;
+				itemBuildCode = itemBuildCode + `${inlinedValueFromString(key)}:${itemOutput.i},`;
+			}
+			let output = B_next(input, outputVar, outputSchema, outputSchema);
+			output.v = _var;
+			output.cp = `let ${outputVar}=new Array(Math.max(${lengthCode}));`;
+			let rowAssign;
+			if (hasAsync) {
+				const rowResultVar = B_varWithoutAllocation(input.g);
+				let asyncBuildCode = "";
+				for (let idx = 0; idx <= keysLen - 1; ++idx) {
+					const key = keys[idx];
+					asyncBuildCode = asyncBuildCode + `${inlinedValueFromString(key)}:${rowResultVar}[${idx}],`;
+				}
+				rowAssign = `${outputVar}[${iteratorVar}]=Promise.all([${asyncInlines}]).then(${rowResultVar}=>({${asyncBuildCode}}));`;
+			} else rowAssign = `${outputVar}[${iteratorVar}]={${itemBuildCode}};`;
+			const rowBody = itemParseCode + rowAssign;
+			let wrappedBody;
+			if (itemParseCode === "") wrappedBody = rowBody;
+			else {
+				const errorVar = B_varWithoutAllocation(input.g);
+				wrappedBody = `try{${rowBody}}catch(${errorVar}){${errorVar}.path='["'+${iteratorVar}+'"]'+${errorVar}.path;throw ${errorVar}}`;
+			}
+			output.cp = output.cp + `for(let ${iteratorVar}=0;${iteratorVar}<${outputVar}.length;++${iteratorVar}){${wrappedBody}}`;
+			if (hasAsync) output = B_asyncVal(output, `Promise.all(${outputVar})`);
+			return B_markOutput(output, input);
+		} else {
+			const inputVar = input.v();
+			const iteratorVar = B_varWithoutAllocation(input.g);
+			const outputVar = B_varWithoutAllocation(input.g);
+			const needsPerFieldTransform = declaredItemSchema !== unknown;
+			let initialArraysCode = "";
+			let settingCode = "";
+			let perFieldCode = "";
+			for (let idx = 0; idx <= keysLen - 1; ++idx) {
+				const key = keys[idx];
+				initialArraysCode = initialArraysCode + `new Array(${inputVar}.length),`;
+				if (needsPerFieldTransform) {
+					const fieldSchema = properties[key];
+					const rawValueCode = `${inputVar}[${iteratorVar}][${inlinedValueFromString(key)}]`;
+					const itemInput = B_scope(input);
+					itemInput.i = rawValueCode;
+					itemInput.s = fieldSchema;
+					itemInput.e = declaredItemSchema;
+					itemInput.v = _notVarBeforeValidation;
+					itemInput.io = false;
+					itemInput.path = pathFromInlinedLocation(B_inlineLocation(input.g, key));
+					const itemOutput = parse(itemInput);
+					perFieldCode = perFieldCode + B_merge(itemOutput);
+					settingCode = settingCode + `${outputVar}[${idx}][${iteratorVar}]=${itemOutput.i};`;
+				} else settingCode = settingCode + `${outputVar}[${idx}][${iteratorVar}]=${inputVar}[${iteratorVar}][${inlinedValueFromString(key)}];`;
+			}
+			const output = B_next(input, outputVar, outputSchema, outputSchema);
+			output.v = _var;
+			output.cp = `let ${outputVar}=[${initialArraysCode}];`;
+			const loopBody = perFieldCode + settingCode;
+			let wrappedBody;
+			if (needsPerFieldTransform && perFieldCode !== "") {
+				const errorVar = B_varWithoutAllocation(input.g);
+				wrappedBody = `try{${loopBody}}catch(${errorVar}){${errorVar}.path='["'+${iteratorVar}+'"]'+${errorVar}.path;throw ${errorVar}}`;
+			} else wrappedBody = loopBody;
+			output.cp = output.cp + `for(let ${iteratorVar}=0;${iteratorVar}<${inputVar}.length;++${iteratorVar}){${wrappedBody}}`;
+			return B_markOutput(output, input);
+		}
+	}
+};
+var compactColumns = (inputSchema) => {
+	const mut = array(array(inputSchema));
+	mut.format = "compactColumns";
+	mut.decoder = compactColumnsDecoder;
+	return mut;
+};
+var object = schemaObject;
+var nullAsOption = (item) => optionFactory(item, nullAsUnit());
+var null_ = (item) => unionFactory([item, nullLiteral()]);
+var dict = dictFactory;
+var shape = schemaShape;
+var tuple = schemaTuple;
+var union = unionFactory;
+var assertNumber = (fnName, n) => {
+	if (typeof n !== numberTag || Number.isNaN(n)) throw new SuryError({
+		code: "invalid_operation",
+		path: pathEmpty,
+		reason: `[S.${fnName}] Expected number, received ${stringify(n)}`
+	});
+};
+var intMin = (schema, minValue, maybeMessage) => {
+	assertNumber("min", minValue);
+	const message = maybeMessage ?? `Number must be greater than or equal to ${minValue}`;
+	return internalRefine(schema, (mut) => {
+		mut.minimum = minValue;
+		getMutErrorMessage(mut)["minimum"] = message;
+		return (_input) => {
+			return [{
+				c: (inputVar) => `${inputVar}>${minValue - 1}`,
+				f: B_failWithErrorMessage("minimum", message)
+			}];
+		};
+	});
+};
+var intMax = (schema, maxValue, maybeMessage) => {
+	assertNumber("max", maxValue);
+	const message = maybeMessage ?? `Number must be lower than or equal to ${maxValue}`;
+	return internalRefine(schema, (mut) => {
+		mut.maximum = maxValue;
+		getMutErrorMessage(mut)["maximum"] = message;
+		return (_input) => {
+			return [{
+				c: (inputVar) => `${inputVar}<${maxValue + 1}`,
+				f: B_failWithErrorMessage("maximum", message)
+			}];
+		};
+	});
+};
+var floatMin = (schema, minValue, maybeMessage) => {
+	assertNumber("min", minValue);
+	const message = maybeMessage ?? `Number must be greater than or equal to ${minValue}`;
+	return internalRefine(schema, (mut) => {
+		mut.minimum = minValue;
+		getMutErrorMessage(mut)["minimum"] = message;
+		return (input) => {
+			return [{
+				c: (inputVar) => `${inputVar}>=${B_embed(input, minValue)}`,
+				f: B_failWithErrorMessage("minimum", message)
+			}];
+		};
+	});
+};
+var floatMax = (schema, maxValue, maybeMessage) => {
+	assertNumber("max", maxValue);
+	const message = maybeMessage ?? `Number must be lower than or equal to ${maxValue}`;
+	return internalRefine(schema, (mut) => {
+		mut.maximum = maxValue;
+		getMutErrorMessage(mut)["maximum"] = message;
+		return (input) => {
+			return [{
+				c: (inputVar) => `${inputVar}<=${B_embed(input, maxValue)}`,
+				f: B_failWithErrorMessage("maximum", message)
+			}];
+		};
+	});
+};
+var arrayMinLength = (schema, length2, maybeMessage) => {
+	assertNumber("min", length2);
+	const message = maybeMessage ?? `Array must be ${length2} or more items long`;
+	return internalRefine(schema, (mut) => {
+		mut.minItems = length2;
+		getMutErrorMessage(mut)["minItems"] = message;
+		return (_input) => {
+			return [{
+				c: (inputVar) => `${inputVar}.length>${length2 - 1}`,
+				f: B_failWithErrorMessage("minItems", message)
+			}];
+		};
+	});
+};
+var arrayMaxLength = (schema, length2, maybeMessage) => {
+	assertNumber("max", length2);
+	const message = maybeMessage ?? `Array must be ${length2} or fewer items long`;
+	return internalRefine(schema, (mut) => {
+		mut.maxItems = length2;
+		getMutErrorMessage(mut)["maxItems"] = message;
+		return (_input) => {
+			return [{
+				c: (inputVar) => `${inputVar}.length<${length2 + 1}`,
+				f: B_failWithErrorMessage("maxItems", message)
+			}];
+		};
+	});
+};
+var arrayLength = (schema, length2, maybeMessage) => {
+	assertNumber("length", length2);
+	const message = maybeMessage ?? `Array must be exactly ${length2} items long`;
+	return internalRefine(schema, (mut) => {
+		mut.minItems = length2;
+		mut.maxItems = length2;
+		const em = getMutErrorMessage(mut);
+		em["minItems"] = message;
+		em["maxItems"] = message;
+		return (_input) => {
+			return [{
+				c: (inputVar) => `${inputVar}.length===${length2}`,
+				f: B_failWithErrorMessage("minItems", message)
+			}];
+		};
+	});
+};
+var stringMinLength = (schema, length2, maybeMessage) => {
+	assertNumber("min", length2);
+	const message = maybeMessage ?? `String must be ${length2} or more characters long`;
+	return internalRefine(schema, (mut) => {
+		mut.minLength = length2;
+		getMutErrorMessage(mut)["minLength"] = message;
+		return (_input) => {
+			return [{
+				c: (inputVar) => `${inputVar}.length>${length2 - 1}`,
+				f: B_failWithErrorMessage("minLength", message)
+			}];
+		};
+	});
+};
+var stringMaxLength = (schema, length2, maybeMessage) => {
+	assertNumber("max", length2);
+	const message = maybeMessage ?? `String must be ${length2} or fewer characters long`;
+	return internalRefine(schema, (mut) => {
+		mut.maxLength = length2;
+		getMutErrorMessage(mut)["maxLength"] = message;
+		return (_input) => {
+			return [{
+				c: (inputVar) => `${inputVar}.length<${length2 + 1}`,
+				f: B_failWithErrorMessage("maxLength", message)
+			}];
+		};
+	});
+};
+var stringLength = (schema, length2, maybeMessage) => {
+	assertNumber("length", length2);
+	const message = maybeMessage ?? `String must be exactly ${length2} characters long`;
+	return internalRefine(schema, (mut) => {
+		mut.minLength = length2;
+		mut.maxLength = length2;
+		const em = getMutErrorMessage(mut);
+		em["minLength"] = message;
+		em["maxLength"] = message;
+		return (_input) => {
+			return [{
+				c: (inputVar) => `${inputVar}.length===${length2}`,
+				f: B_failWithErrorMessage("minLength", message)
+			}];
+		};
+	});
+};
+var pattern = (schema, re, message = `Invalid pattern`) => {
+	return internalRefine(schema, (mut) => {
+		mut.pattern = re;
+		getMutErrorMessage(mut)["pattern"] = message;
+		return (input) => {
+			const embededRe = B_embed(input, re);
+			return [{
+				c: (inputVar) => re.global ? `(${embededRe}.lastIndex=0,${embededRe}.test(${inputVar}))` : `${embededRe}.test(${inputVar})`,
+				f: B_failWithErrorMessage("pattern", message)
+			}];
+		};
+	});
+};
+var trim = (schema) => {
+	const transformer = (string3) => string3.trim();
+	return transform(schema, (_) => ({
+		p: transformer,
+		s: transformer
+	}));
+};
+var nullable = (schema) => {
+	return unionFactory([
+		schema,
+		unit(),
+		nullLiteral()
+	]);
+};
+var nullableAsOption = (schema) => {
+	return unionFactory([
+		schema,
+		unit(),
+		nullAsUnit()
+	]);
+};
+var jsonSchemaMetadataId = /* @__PURE__ */ Metadata_Id_internal("JSONSchema");
+var jsonSchemaMerge = (a, b) => {
+	return Object.assign({}, a, b);
+};
+var applyMetadataOverlay = (jsonSchema, schema, defs) => {
+	if (schema.description !== void 0) jsonSchema.description = schema.description;
+	if (schema.title !== void 0) jsonSchema.title = schema.title;
+	if (schema.deprecated !== void 0) jsonSchema.deprecated = schema.deprecated;
+	if (schema.examples !== void 0) jsonSchema.examples = schema.examples;
+	if (schema["$defs"] !== void 0) Object.assign(defs, schema["$defs"]);
+	const metadataRawSchema = Metadata_get(schema, jsonSchemaMetadataId);
+	if (metadataRawSchema !== void 0) Object.assign(jsonSchema, metadataRawSchema);
+};
+var encodeToJsonSchema = (schema, path, defs, parent, target) => {
+	const input = B_operationArg(unknown, reverse(schema), flagNone, void 0);
+	try {
+		return internalToJSONSchema(parse(input).s, path, defs, parent, target);
+	} catch (exn) {
+		getOrRethrow(exn);
+		return;
+	}
+};
+var internalToJSONSchema = (schema, path, defs, parent, target) => {
+	const schemaInternal = schema;
+	const tagFlag = tagFlags[schemaInternal.type];
+	const encoded = !!schemaInternal.to && !flagUnsafeHas(tagFlag, 192) && !(flagUnsafeHas(tagFlag, tagFlagUnion) && !!schemaInternal.parser) ? encodeToJsonSchema(schema, path, defs, parent, target) : void 0;
+	if (encoded !== void 0) {
+		applyMetadataOverlay(encoded, schema, defs);
+		return encoded;
+	} else return internalToJSONSchemaBase(schema, path, defs, parent, target);
+};
+var internalToJSONSchemaBase = (schema, path, defs, parent, target) => {
+	const jsonSchema = {};
+	const setConstOrEnum = (value) => {
+		if (target === "openapi-3.0") jsonSchema.enum = [value];
+		else jsonSchema.const = value;
+	};
+	const tag = schema.type;
+	if (tag === stringTag) {
+		const const_ = schema.const;
+		const format = schema.format;
+		jsonSchema.type = "string";
+		switch (format) {
+			case "date-time":
+				jsonSchema.format = "date-time";
+				break;
+			case "email":
+				jsonSchema.format = "email";
+				break;
+			case "uuid":
+				jsonSchema.format = "uuid";
+				break;
+			case "url":
+				jsonSchema.format = "uri";
+				break;
+			default: break;
+		}
+		if (schema.minLength !== void 0) jsonSchema.minLength = schema.minLength;
+		if (schema.maxLength !== void 0) jsonSchema.maxLength = schema.maxLength;
+		if (schema.pattern !== void 0) jsonSchema.pattern = schema.pattern.source;
+		if (const_ !== void 0) setConstOrEnum(const_);
+	} else if (tag === numberTag) {
+		const format = schema.format;
+		const const_ = schema.const;
+		if (format === "int32") {
+			jsonSchema.type = "integer";
+			jsonSchema.minimum = -2147483648;
+			jsonSchema.maximum = 2147483647;
+		} else if (format === "port") {
+			jsonSchema.type = "integer";
+			jsonSchema.minimum = 0;
+			jsonSchema.maximum = 65535;
+		} else jsonSchema.type = "number";
+		if (schema.minimum !== void 0) jsonSchema.minimum = schema.minimum;
+		if (schema.maximum !== void 0) jsonSchema.maximum = schema.maximum;
+		if (const_ !== void 0) setConstOrEnum(const_);
+	} else if (tag === booleanTag) {
+		const const_ = schema.const;
+		jsonSchema.type = "boolean";
+		if (const_ !== void 0) setConstOrEnum(const_);
+	} else if (tag === arrayTag) {
+		const additionalItems = schema.additionalItems;
+		const items = schema.items;
+		if (typeof additionalItems === "object") {
+			jsonSchema.items = internalToJSONSchema(additionalItems, pathConcat(path, pathDynamic), defs, schema, target);
+			jsonSchema.type = "array";
+			if (schema.minItems !== void 0) jsonSchema.minItems = schema.minItems;
+			if (schema.maxItems !== void 0) jsonSchema.maxItems = schema.maxItems;
+		} else {
+			const itemDefinitions = items.map((itemSchema, idx) => {
+				return internalToJSONSchema(itemSchema, pathConcat(path, pathFromLocation(idx.toString())), defs, schema, target);
+			});
+			const itemsNumber = itemDefinitions.length;
+			jsonSchema.type = "array";
+			jsonSchema.minItems = itemsNumber;
+			jsonSchema.maxItems = itemsNumber;
+			if (target === "openapi-3.0") jsonSchema.items = { anyOf: itemDefinitions };
+			else if (target === "draft-2020-12") jsonSchema.prefixItems = itemDefinitions;
+			else jsonSchema.items = itemDefinitions;
+		}
+	} else if (tag === unionTag) {
+		const anyOf = schema.anyOf;
+		const literals = [];
+		const items = [];
+		const seen = {};
+		anyOf.forEach((childSchema) => {
+			if (!(childSchema.type === undefinedTag && parent.type === objectTag)) {
+				const childJsonSchema = internalToJSONSchema(childSchema, path, defs, schema, target);
+				const key = JSON.stringify(childJsonSchema);
+				if (!(key in seen)) {
+					seen[key] = true;
+					items.push(childJsonSchema);
+					if (isLiteral(childSchema)) literals.push(childSchema.const);
+				}
+			}
+		});
+		const itemsNumber = items.length;
+		if (schema.default !== void 0) jsonSchema.default = schema.default;
+		const isNullDefinition = (definition) => {
+			if (typeof definition !== "boolean") {
+				const t = definition;
+				if (t.type === "null") return true;
+				else if (t.enum !== void 0 && t.enum.length === 1 && t.enum[0] === null) return true;
+				else return false;
+			} else return false;
+		};
+		if (itemsNumber === 1) Object.assign(jsonSchema, items[0]);
+		else if (literals.length === itemsNumber) jsonSchema.enum = literals;
+		else if (target === "openapi-3.0" && itemsNumber === 2 && (isNullDefinition(items[0]) || isNullDefinition(items[1]))) {
+			const nonNull = items[isNullDefinition(items[0]) ? 1 : 0];
+			if (typeof nonNull !== "boolean") {
+				Object.assign(jsonSchema, nonNull);
+				jsonSchema.nullable = true;
+			} else jsonSchema.anyOf = items;
+		} else jsonSchema.anyOf = items;
+	} else if (tag === objectTag) {
+		const properties = schema.properties;
+		const additionalItems = schema.additionalItems;
+		if (typeof additionalItems === "object") {
+			jsonSchema.type = "object";
+			const childJsonSchema = internalToJSONSchema(additionalItems, pathConcat(path, pathDynamic), defs, schema, target);
+			jsonSchema.additionalProperties = Object.keys(childJsonSchema).length === 0 ? true : childJsonSchema;
+		} else {
+			const required = [];
+			const jsonProperties = {};
+			Object.keys(properties).forEach((key) => {
+				const itemSchema = properties[key];
+				const fieldSchema = internalToJSONSchema(itemSchema, pathConcat(path, pathFromLocation(key)), defs, schema, target);
+				if (!isOptional(itemSchema)) required.push(key);
+				jsonProperties[key] = fieldSchema;
+			});
+			jsonSchema.type = "object";
+			jsonSchema.properties = jsonProperties;
+			if (additionalItems === "strict") jsonSchema.additionalProperties = false;
+			if (required.length !== 0) jsonSchema.required = required;
+		}
+	} else if (tag === refTag && schema["$ref"] === `${defsPath}${jsonName}`) {} else if (tag === refTag) jsonSchema.$ref = schema["$ref"];
+	else if (tag === nullTag) if (target === "openapi-3.0") jsonSchema.enum = [null];
+	else jsonSchema.type = "null";
+	else if (tag === neverTag) jsonSchema.not = {};
+	else throw new SuryError(B_makeInvalidInputDetails((() => {
+		const s2 = baseSchema(unknownTag, false);
+		s2.name = jsonName;
+		return s2;
+	})(), flagUnsafeHas(tagFlags[parent.type], tagFlagUnion) ? parent : schema, path, void 0, false));
+	applyMetadataOverlay(jsonSchema, schema, defs);
+	return jsonSchema;
+};
+var targetSchemaUri = (target) => {
+	switch (target) {
+		case "draft-07": return "http://json-schema.org/draft-07/schema#";
+		case "draft-2020-12": return "https://json-schema.org/draft/2020-12/schema";
+		case "openapi-3.0": return;
+		default: throw new SuryError({
+			code: "invalid_operation",
+			path: pathEmpty,
+			reason: `Unsupported JSON Schema target: ${target}`
+		});
+	}
+};
+var toJSONSchema = (schema, options) => {
+	let target;
+	let schemaUri;
+	if (options !== void 0) {
+		target = options.target !== void 0 ? options.target : "draft-07";
+		schemaUri = targetSchemaUri(target);
+	} else {
+		target = "draft-07";
+		schemaUri = void 0;
+	}
+	const defs = {};
+	const jsonSchema = internalToJSONSchema(schema, pathEmpty, defs, schema, target);
+	delete defs.JSON;
+	const defsKeys = Object.keys(defs);
+	if (defsKeys.length) {
+		const jsonSchemDefs = defs;
+		defsKeys.forEach((key) => {
+			const schema2 = defs[key];
+			jsonSchemDefs[key] = internalToJSONSchema(schema2, pathEmpty, {}, schema2, target);
+		});
+		jsonSchema.$defs = jsonSchemDefs;
+	}
+	if (schemaUri !== void 0) jsonSchema.$schema = schemaUri;
+	return jsonSchema;
+};
+var enableStandardJSONSchema = () => {
+	__setStandardJSONSchemaConverter((schema, options, isOutput) => {
+		return toJSONSchema(isOutput ? reverse(schema) : schema, { target: options.target });
+	});
+};
+var extendJSONSchema = (schema, jsonSchema) => {
+	const existingSchemaExtend = Metadata_get(schema, jsonSchemaMetadataId);
+	return Metadata_set(schema, jsonSchemaMetadataId, existingSchemaExtend !== void 0 ? jsonSchemaMerge(existingSchemaExtend, jsonSchema) : jsonSchema);
+};
+var primitiveToSchema = (primitive) => {
+	return Literal_parse(primitive);
+};
+var toIntSchema = (jsonSchema) => {
+	let schema = int();
+	if (jsonSchema.minimum !== void 0) schema = intMin(schema, jsonSchema.minimum | 0);
+	else if (jsonSchema.exclusiveMinimum !== void 0) schema = intMin(schema, jsonSchema.exclusiveMinimum + 1 | 0);
+	if (jsonSchema.maximum !== void 0) schema = intMax(schema, jsonSchema.maximum | 0);
+	else if (jsonSchema.exclusiveMinimum !== void 0) schema = intMax(schema, jsonSchema.exclusiveMinimum - 1 | 0);
+	return schema;
+};
+var definitionToDefaultValue = (definition) => {
+	if (typeof definition !== "boolean") return definition.default;
+	else return;
+};
+var fromJSONSchema = (jsonSchema) => {
+	const anySchema = json();
+	const jsonDefinitionToSchema = (definition) => {
+		if (typeof definition !== "boolean") return fromJSONSchema(definition);
+		else if (definition === true) return anySchema;
+		else return never_();
+	};
+	let schema;
+	if (jsonSchema.nullable) schema = null_(fromJSONSchema(jsonSchemaMerge(jsonSchema, { nullable: false })));
+	else if (jsonSchema.type === "object") if (jsonSchema.properties !== void 0) {
+		const properties = jsonSchema.properties;
+		const obj = {};
+		Object.keys(properties).forEach((key) => {
+			const property = properties[key];
+			let propertySchema = jsonDefinitionToSchema(property);
+			if (!jsonSchema.required?.includes(key)) {
+				const defaultValue = definitionToDefaultValue(property);
+				if (defaultValue !== void 0) propertySchema = Option_getOr(option(propertySchema), defaultValue);
+				else propertySchema = option(propertySchema);
+			}
+			obj[key] = propertySchema;
+		});
+		schema = definitionToSchema(obj);
+		if (jsonSchema.additionalProperties === false) schema = strict(schema);
+	} else {
+		const additionalProperties = jsonSchema.additionalProperties;
+		if (additionalProperties !== void 0) if (additionalProperties === true) schema = dict(anySchema);
+		else if (additionalProperties === false) schema = strict(object(() => {}));
+		else schema = dict(fromJSONSchema(additionalProperties));
+		else schema = schemaFactory({});
+	}
+	else if (jsonSchema.type === "array") {
+		if (jsonSchema.prefixItems !== void 0) {
+			const prefixItems = jsonSchema.prefixItems;
+			schema = tuple((s2) => prefixItems.map((d, idx) => s2.item(idx, jsonDefinitionToSchema(d))));
+		} else if (jsonSchema.items !== void 0) {
+			const items = jsonSchema.items;
+			if (Array.isArray(items)) schema = tuple((s2) => items.map((d, idx) => s2.item(idx, jsonDefinitionToSchema(d))));
+			else schema = array(jsonDefinitionToSchema(items));
+		} else schema = array(anySchema);
+		if (jsonSchema.minItems !== void 0) schema = arrayMinLength(schema, jsonSchema.minItems);
+		if (jsonSchema.maxItems !== void 0) schema = arrayMaxLength(schema, jsonSchema.maxItems);
+	} else if (jsonSchema.anyOf !== void 0) {
+		const definitions = jsonSchema.anyOf;
+		if (definitions.length === 0) schema = anySchema;
+		else if (definitions.length === 1) schema = jsonDefinitionToSchema(definitions[0]);
+		else schema = union(definitions.map(jsonDefinitionToSchema));
+	} else if (jsonSchema.allOf !== void 0) {
+		const definitions = jsonSchema.allOf;
+		if (definitions.length === 0) schema = anySchema;
+		else if (definitions.length === 1) schema = jsonDefinitionToSchema(definitions[0]);
+		else schema = refine(anySchema, (data) => {
+			return definitions.every((d) => {
+				try {
+					assertOrThrow(data, jsonDefinitionToSchema(d));
+					return true;
+				} catch (_) {
+					return false;
+				}
+			});
+		}, "Should pass for all schemas of the allOf property.");
+	} else if (jsonSchema.oneOf !== void 0) {
+		const definitions = jsonSchema.oneOf;
+		if (definitions.length === 0) schema = anySchema;
+		else if (definitions.length === 1) schema = jsonDefinitionToSchema(definitions[0]);
+		else schema = refine(anySchema, (data) => {
+			let validCount = 0;
+			definitions.forEach((d) => {
+				try {
+					assertOrThrow(data, jsonDefinitionToSchema(d));
+					validCount = validCount + 1;
+				} catch {}
+			});
+			return validCount === 1;
+		}, "Should pass exactly one schema according to the oneOf property.");
+	} else if (jsonSchema.not !== void 0) {
+		const not = jsonSchema.not;
+		schema = refine(anySchema, (data) => {
+			try {
+				assertOrThrow(data, jsonDefinitionToSchema(not));
+				return false;
+			} catch (_) {
+				return true;
+			}
+		}, "Should NOT be valid against schema in the not property.");
+	} else if (jsonSchema.enum !== void 0) {
+		const primitives = jsonSchema.enum;
+		if (primitives.length === 0) schema = anySchema;
+		else if (primitives.length === 1) schema = primitiveToSchema(primitives[0]);
+		else schema = union(primitives.map(primitiveToSchema));
+	} else if (jsonSchema.const !== void 0) schema = primitiveToSchema(jsonSchema.const);
+	else if (Array.isArray(jsonSchema.type)) {
+		const types = jsonSchema.type;
+		schema = union(types.map((type) => fromJSONSchema(jsonSchemaMerge(jsonSchema, { type }))));
+	} else if (jsonSchema.type === "string") {
+		if (jsonSchema.format === "email") schema = email();
+		else if (jsonSchema.format === "uri") schema = url();
+		else if (jsonSchema.format === "uuid") schema = uuid();
+		else if (jsonSchema.format === "date-time") schema = isoDateTime();
+		else schema = string();
+		if (jsonSchema.pattern !== void 0) schema = pattern(schema, new RegExp(jsonSchema.pattern));
+		if (jsonSchema.minLength !== void 0) schema = stringMinLength(schema, jsonSchema.minLength);
+		if (jsonSchema.maxLength !== void 0) schema = stringMaxLength(schema, jsonSchema.maxLength);
+	} else if (jsonSchema.type === "integer") schema = toIntSchema(jsonSchema);
+	else if (jsonSchema.type === "number" && jsonSchema.format === "int64") schema = toIntSchema(jsonSchema);
+	else if (jsonSchema.type === "number" && jsonSchema.multipleOf === 1) schema = toIntSchema(jsonSchema);
+	else if (jsonSchema.type === "number") {
+		schema = float();
+		if (jsonSchema.minimum !== void 0) schema = floatMin(schema, jsonSchema.minimum);
+		else if (jsonSchema.exclusiveMinimum !== void 0) schema = floatMin(schema, jsonSchema.exclusiveMinimum + 1);
+		if (jsonSchema.maximum !== void 0) schema = floatMax(schema, jsonSchema.maximum);
+		else if (jsonSchema.exclusiveMinimum !== void 0) schema = floatMax(schema, jsonSchema.exclusiveMinimum - 1);
+	} else if (jsonSchema.type === "boolean") schema = bool();
+	else if (jsonSchema.type === "null") schema = schemaFactory(null);
+	else if (jsonSchema.if !== void 0 && jsonSchema.then !== void 0 && jsonSchema.else !== void 0) {
+		const ifSchema = jsonDefinitionToSchema(jsonSchema.if);
+		const thenSchema = jsonDefinitionToSchema(jsonSchema.then);
+		const elseSchema = jsonDefinitionToSchema(jsonSchema.else);
+		schema = refine(anySchema, (data) => {
+			let passed;
+			try {
+				assertOrThrow(data, ifSchema);
+				passed = true;
+			} catch (_) {
+				passed = false;
+			}
+			try {
+				if (passed) assertOrThrow(data, thenSchema);
+				else assertOrThrow(data, elseSchema);
+				return true;
+			} catch (_) {
+				return false;
+			}
+		}, "Should pass the if/then/else schema validation.");
+	} else if (jsonSchema.type !== void 0) throw new SuryError({
+		code: "invalid_operation",
+		path: pathEmpty,
+		reason: `Unsupported JSON Schema type: ${jsonSchema.type}`
+	});
+	else schema = anySchema;
+	if (jsonSchema.description !== void 0 || jsonSchema.deprecated !== void 0 || jsonSchema.examples !== void 0 || jsonSchema.title !== void 0) schema = meta(schema, {
+		title: jsonSchema.title,
+		description: jsonSchema.description,
+		deprecated: jsonSchema.deprecated,
+		examples: jsonSchema.examples
+	});
+	return schema;
+};
+var min = (schema, minValue, maybeMessage) => {
+	switch (schema.type) {
+		case stringTag: return stringMinLength(schema, minValue, maybeMessage);
+		case arrayTag: return arrayMinLength(schema, minValue, maybeMessage);
+		case numberTag: return schema.format === "int32" || schema.format === "port" ? intMin(schema, minValue, maybeMessage) : floatMin(schema, minValue, maybeMessage);
+		default: return panic(`S.min is not supported for ${toExpression(schema)} schema. Coerce the schema to string, number or array using S.to first.`);
+	}
+};
+var max = (schema, maxValue, maybeMessage) => {
+	switch (schema.type) {
+		case stringTag: return stringMaxLength(schema, maxValue, maybeMessage);
+		case arrayTag: return arrayMaxLength(schema, maxValue, maybeMessage);
+		case numberTag: return schema.format === "int32" || schema.format === "port" ? intMax(schema, maxValue, maybeMessage) : floatMax(schema, maxValue, maybeMessage);
+		default: return panic(`S.max is not supported for ${toExpression(schema)} schema. Coerce the schema to string, number or array using S.to first.`);
+	}
+};
+var length = (schema, length2, maybeMessage) => {
+	switch (schema.type) {
+		case stringTag: return stringLength(schema, length2, maybeMessage);
+		case arrayTag: return arrayLength(schema, length2, maybeMessage);
+		default: return panic(`S.length is not supported for ${toExpression(schema)} schema. Coerce the schema to string or array using S.to first.`);
+	}
+};
+var string2 = /* @__PURE__ */ string();
+var _boolean = /* @__PURE__ */ bool();
+var _int32 = /* @__PURE__ */ int();
+var _number = /* @__PURE__ */ float();
+var bigint2 = /* @__PURE__ */ bigint();
+var symbol2 = /* @__PURE__ */ symbol();
+var never = /* @__PURE__ */ never_();
+var nan2 = /* @__PURE__ */ nan();
+var _void = /* @__PURE__ */ void_();
+var $res_unit = /* @__PURE__ */ unit();
+var $res_nullAsUnit = /* @__PURE__ */ nullAsUnit();
+var json2 = /* @__PURE__ */ json();
+var jsonString2 = /* @__PURE__ */ jsonString();
+var uint8Array2 = /* @__PURE__ */ uint8Array();
+var date2 = /* @__PURE__ */ date();
+var isoDateTime2 = /* @__PURE__ */ isoDateTime();
+var port2 = /* @__PURE__ */ port();
+var email2 = /* @__PURE__ */ email();
+var uuid2 = /* @__PURE__ */ uuid();
+var cuid2 = /* @__PURE__ */ cuid();
+var url2 = /* @__PURE__ */ url();
+//#endregion
+export { Metadata_Id_make as $res_Metadata_Id_make, Metadata_get as $res_Metadata_get, Metadata_set as $res_Metadata_set, Option_getOr as $res_Option_getOr, Option_getOrWith as $res_Option_getOrWith, assertAsyncOrThrow as $res_assertAsyncOrThrow, nullAsOption as $res_nullAsOption, $res_nullAsUnit, nullableAsOption as $res_nullableAsOption, option as $res_option, pathConcat as $res_pathConcat, pathFromArray as $res_pathFromArray, pathFromLocation as $res_pathFromLocation, pathToArray as $res_pathToArray, schemaDefiner as $res_schema, __setExnId as $res_setExnId, transform as $res_transform, $res_unit, errorClass as Error, unknown as any, unknown, array, js_assert as assert, js_asyncDecoder as asyncDecoder, js_asyncDecoderAssert as asyncDecoderAssert, js_asyncEncoder as asyncEncoder, js_asyncParser as asyncParser, bigint2 as bigint, _boolean as bool, _boolean as boolean, brand, compactColumns, cuid2 as cuid, date2 as date, getDecoder as decoder, deepStrict, deepStrip, dict, dict as record, email2 as email, enableStandardJSONSchema, js_encoder as encoder, enum_ as enum, extendJSONSchema, _number as float, _number as number, fromJSONSchema, global, instance, _int32 as int, _int32 as int32, js_is as is, isAsync, isoDateTime2 as isoDateTime, json2 as json, jsonString2 as jsonString, jsonStringWithSpace, length, list, schemaFactory as literal, schemaFactory as schema, max, js_merge as merge, meta, min, nan2 as nan, never, noValidation, js_nullable as nullable, nullable as nullish, object, js_optional as optional, js_parser as parser, pattern, port2 as port, recursive, js_refine as refine, reverse, js_safe as safe, js_safeAsync as safeAsync, shape, strict, string2 as string, strip, symbol2 as symbol, js_to as to, toExpression, toJSONSchema, trim, tuple, uint8Array2 as uint8Array, js_union as union, url2 as url, uuid2 as uuid, _void as void };