@atscript/typescript 0.1.34 → 0.1.35

package/dist/json-schema-0UUPoHud.mjs

@@ -0,0 +1,952 @@
+
+//#region packages/typescript/src/validator.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+const regexCache = new Map();
+var Validator = class {
+	isLimitExceeded() {
+		if (this.stackErrors.length > 0) {
+			const top = this.stackErrors[this.stackErrors.length - 1];
+			return top !== null && top.length >= this.opts.errorLimit;
+		}
+		return this.errors.length >= this.opts.errorLimit;
+	}
+	push(name) {
+		this.stackPath.push(name);
+		this.stackErrors.push(null);
+		this.cachedPath = this.stackPath.length <= 1 ? "" : this.stackPath[1] + (this.stackPath.length > 2 ? "." + this.stackPath.slice(2).join(".") : "");
+	}
+	pop(saveErrors) {
+		this.stackPath.pop();
+		const popped = this.stackErrors.pop();
+		if (saveErrors && popped !== null && popped !== undefined && popped.length > 0) for (const err of popped) this.error(err.message, err.path, err.details);
+		this.cachedPath = this.stackPath.length <= 1 ? "" : this.stackPath[1] + (this.stackPath.length > 2 ? "." + this.stackPath.slice(2).join(".") : "");
+		return popped;
+	}
+	clear() {
+		this.stackErrors[this.stackErrors.length - 1] = null;
+	}
+	error(message, path, details) {
+		let errors = this.stackErrors[this.stackErrors.length - 1];
+		if (!errors) if (this.stackErrors.length > 0) {
+			errors = [];
+			this.stackErrors[this.stackErrors.length - 1] = errors;
+		} else errors = this.errors;
+		const error = {
+			path: path || this.cachedPath,
+			message
+		};
+		if (details?.length) error.details = details;
+		errors.push(error);
+	}
+	throw() {
+		throw new ValidatorError(this.errors);
+	}
+	/**
+	* Validates a value against the type definition.
+	*
+	* Acts as a TypeScript type guard — when it returns `true`, the value
+	* is narrowed to `DataType`.
+	*
+	* @param value - The value to validate.
+	* @param safe - If `true`, returns `false` on failure instead of throwing.
+	* @returns `true` if the value matches the type definition.
+	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
+	*/ validate(value, safe, context) {
+		this.errors = [];
+		this.stackErrors = [];
+		this.stackPath = [""];
+		this.cachedPath = "";
+		this.context = context;
+		const passed = this.validateSafe(this.def, value);
+		this.pop(!passed);
+		this.context = undefined;
+		if (!passed) {
+			if (safe) return false;
+			this.throw();
+		}
+		return true;
+	}
+	validateSafe(def, value) {
+		if (this.isLimitExceeded()) return false;
+		if (!isAnnotatedType(def)) throw new Error("Can not validate not-annotated type");
+		if (typeof this.opts.replace === "function") def = this.opts.replace(def, this.cachedPath);
+		if (def.optional && (value === undefined || value === null)) return true;
+		for (const plugin of this.opts.plugins) {
+			const result = plugin(this, def, value);
+			if (result === false || result === true) return result;
+		}
+		return this.validateAnnotatedType(def, value);
+	}
+	get path() {
+		return this.cachedPath;
+	}
+	validateAnnotatedType(def, value) {
+		switch (def.type.kind) {
+			case "": {
+				if (def.type.designType === "phantom") return true;
+				return this.validatePrimitive(def, value);
+			}
+			case "object": return this.validateObject(def, value);
+			case "array": return this.validateArray(def, value);
+			case "union": return this.validateUnion(def, value);
+			case "intersection": return this.validateIntersection(def, value);
+			case "tuple": return this.validateTuple(def, value);
+			default: throw new Error(`Unknown type kind "${def.type.kind}"`);
+		}
+	}
+	validateUnion(def, value) {
+		let i = 0;
+		const popped = [];
+		for (const item of def.type.items) {
+			this.push(`[${item.type.kind || item.type.designType}(${i})]`);
+			if (this.validateSafe(item, value)) {
+				this.pop(false);
+				return true;
+			}
+			const errors = this.pop(false);
+			if (errors) popped.push(...errors);
+			i++;
+		}
+		this.clear();
+		const expected = def.type.items.map((item, i$1) => `[${item.type.kind || item.type.designType}(${i$1})]`).join(", ");
+		this.error(`Value does not match any of the allowed types: ${expected}`, undefined, popped);
+		return false;
+	}
+	validateIntersection(def, value) {
+		for (const item of def.type.items) if (!this.validateSafe(item, value)) return false;
+		return true;
+	}
+	validateTuple(def, value) {
+		if (!Array.isArray(value) || value.length !== def.type.items.length) {
+			this.error(`Expected array of length ${def.type.items.length}`);
+			return false;
+		}
+		let i = 0;
+		for (const item of def.type.items) {
+			this.push(String(i));
+			if (!this.validateSafe(item, value[i])) {
+				this.pop(true);
+				return false;
+			}
+			this.pop(false);
+			i++;
+		}
+		return true;
+	}
+	validateArray(def, value) {
+		if (!Array.isArray(value)) {
+			this.error("Expected array");
+			return false;
+		}
+		const minLength = def.metadata.get("expect.minLength");
+		if (minLength) {
+			const length = typeof minLength === "number" ? minLength : minLength.length;
+			if (value.length < length) {
+				const message = typeof minLength === "object" && minLength.message ? minLength.message : `Expected minimum length of ${length} items, got ${value.length} items`;
+				this.error(message);
+				return false;
+			}
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (maxLength) {
+			const length = typeof maxLength === "number" ? maxLength : maxLength.length;
+			if (value.length > length) {
+				const message = typeof maxLength === "object" && maxLength.message ? maxLength.message : `Expected maximum length of ${length} items, got ${value.length} items`;
+				this.error(message);
+				return false;
+			}
+		}
+		const uniqueItems = def.metadata.get("expect.array.uniqueItems");
+		if (uniqueItems) {
+			const separator = "▼↩";
+			const seen = new Set();
+			const keyProps = new Set();
+			if (def.type.of.type.kind === "object") {
+				for (const [key, val] of def.type.of.type.props.entries()) if (val.metadata.get("expect.array.key")) keyProps.add(key);
+			}
+			for (let idx = 0; idx < value.length; idx++) {
+				const item = value[idx];
+				let key;
+				if (keyProps.size > 0) {
+					key = "";
+					for (const prop of keyProps) key += JSON.stringify(item[prop]) + separator;
+				} else key = JSON.stringify(item);
+				if (seen.has(key)) {
+					this.push(String(idx));
+					this.error(uniqueItems.message || "Duplicate items are not allowed");
+					this.pop(true);
+					return false;
+				}
+				seen.add(key);
+			}
+		}
+		let i = 0;
+		let passed = true;
+		for (const item of value) {
+			this.push(String(i));
+			if (!this.validateSafe(def.type.of, item)) {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			} else this.pop(false);
+			i++;
+		}
+		return passed;
+	}
+	validateObject(def, value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) {
+			this.error("Expected object");
+			return false;
+		}
+		let passed = true;
+		const valueKeys = new Set(Object.keys(value));
+		const typeKeys = new Set();
+		let skipList;
+		if (this.opts.skipList) {
+			const path = this.stackPath.length > 1 ? `${this.cachedPath}.` : "";
+			for (const item of this.opts.skipList) if (item.startsWith(path)) {
+				const key = item.slice(path.length);
+				if (!skipList) skipList = new Set();
+				skipList.add(key);
+				valueKeys.delete(key);
+			}
+		}
+		let partialFunctionMatched = false;
+		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.cachedPath);
+		for (const [key, item] of def.type.props.entries()) {
+			if (skipList && skipList.has(key) || isPhantomType(item)) continue;
+			typeKeys.add(key);
+			if (value[key] === undefined) {
+				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
+			}
+			this.push(key);
+			if (this.validateSafe(item, value[key])) this.pop(false);
+else {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			}
+		}
+		for (const key of valueKeys)
+ /** matched patterns for unknown keys */ if (!typeKeys.has(key)) {
+			const matched = [];
+			for (const { pattern, def: propDef } of def.type.propsPatterns) if (pattern.test(key)) matched.push({
+				pattern,
+				def: propDef
+			});
+			if (matched.length > 0) {
+				this.push(key);
+				let keyPassed = false;
+				for (const { def: propDef } of matched) {
+					if (this.validateSafe(propDef, value[key])) {
+						keyPassed = true;
+						break;
+					}
+					this.clear();
+				}
+				if (!keyPassed) {
+					this.validateSafe(matched[0].def, value[key]);
+					this.pop(true);
+					passed = false;
+					if (this.isLimitExceeded()) return false;
+				} else this.pop(false);
+			} else if (this.opts.unknownProps !== "ignore") {
+				if (this.opts.unknownProps === "error") {
+					this.push(key);
+					this.error(`Unexpected property`);
+					this.pop(true);
+					if (this.isLimitExceeded()) return false;
+					passed = false;
+				} else if (this.opts.unknownProps === "strip") delete value[key];
+			}
+		}
+		return passed;
+	}
+	validatePrimitive(def, value) {
+		if (def.type.value !== undefined) {
+			if (value !== def.type.value) {
+				this.error(`Expected ${def.type.value}, got ${value}`);
+				return false;
+			}
+			return true;
+		}
+		const typeOfValue = Array.isArray(value) ? "array" : typeof value;
+		switch (def.type.designType) {
+			case "never": {
+				this.error(`This type is impossible, must be an internal problem`);
+				return false;
+			}
+			case "any": return true;
+			case "string": {
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateString(def, value);
+			}
+			case "number": {
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateNumber(def, value);
+			}
+			case "boolean": {
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateBoolean(def, value);
+			}
+			case "undefined": {
+				if (value !== undefined) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			}
+			case "null": {
+				if (value !== null) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			}
+			default: throw new Error(`Unknown type "${def.type.designType}"`);
+		}
+	}
+	validateString(def, value) {
+		const filled = def.metadata.get("meta.required");
+		if (filled) {
+			if (value.trim().length === 0) {
+				const message = typeof filled === "object" && filled.message ? filled.message : `Must not be empty`;
+				this.error(message);
+				return false;
+			}
+		}
+		const minLength = def.metadata.get("expect.minLength");
+		if (minLength) {
+			const length = typeof minLength === "number" ? minLength : minLength.length;
+			if (value.length < length) {
+				const message = typeof minLength === "object" && minLength.message ? minLength.message : `Expected minimum length of ${length} characters, got ${value.length} characters`;
+				this.error(message);
+				return false;
+			}
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (maxLength) {
+			const length = typeof maxLength === "number" ? maxLength : maxLength.length;
+			if (value.length > length) {
+				const message = typeof maxLength === "object" && maxLength.message ? maxLength.message : `Expected maximum length of ${length} characters, got ${value.length} characters`;
+				this.error(message);
+				return false;
+			}
+		}
+		const patterns = def.metadata.get("expect.pattern");
+		for (const { pattern, flags, message } of patterns || []) {
+			if (!pattern) continue;
+			const cacheKey = `${pattern}//${flags || ""}`;
+			let regex = regexCache.get(cacheKey);
+			if (!regex) {
+				regex = new RegExp(pattern, flags);
+				regexCache.set(cacheKey, regex);
+			}
+			if (!regex.test(value)) {
+				this.error(message || `Value is expected to match pattern "${pattern}"`);
+				return false;
+			}
+		}
+		return true;
+	}
+	validateNumber(def, value) {
+		const int = def.metadata.get("expect.int");
+		if (int && value % 1 !== 0) {
+			const message = typeof int === "object" && int.message ? int.message : `Expected integer, got ${value}`;
+			this.error(message);
+			return false;
+		}
+		const min = def.metadata.get("expect.min");
+		if (min) {
+			const minValue = typeof min === "number" ? min : min.minValue;
+			if (value < minValue) {
+				const message = typeof min === "object" && min.message ? min.message : `Expected minimum ${minValue}, got ${value}`;
+				this.error(message);
+				return false;
+			}
+		}
+		const max = def.metadata.get("expect.max");
+		if (max) {
+			const maxValue = typeof max === "number" ? max : max.maxValue;
+			if (value > maxValue) {
+				const message = typeof max === "object" && max.message ? max.message : `Expected maximum ${maxValue}, got ${value}`;
+				this.error(message);
+				return false;
+			}
+		}
+		return true;
+	}
+	validateBoolean(def, value) {
+		const filled = def.metadata.get("meta.required");
+		if (filled) {
+			if (value !== true) {
+				const message = typeof filled === "object" && filled.message ? filled.message : `Must be checked`;
+				this.error(message);
+				return false;
+			}
+		}
+		return true;
+	}
+	constructor(def, opts) {
+		_define_property(this, "def", void 0);
+		_define_property(this, "opts", void 0);
+		/** Validation errors collected during the last {@link validate} call. */ _define_property(this, "errors", void 0);
+		_define_property(this, "stackErrors", void 0);
+		_define_property(this, "stackPath", void 0);
+		_define_property(this, "cachedPath", void 0);
+		_define_property(this, "context", void 0);
+		this.def = def;
+		this.errors = [];
+		this.stackErrors = [];
+		this.stackPath = [];
+		this.cachedPath = "";
+		this.opts = {
+			partial: false,
+			unknownProps: "error",
+			errorLimit: 10,
+			...opts,
+			plugins: opts?.plugins || []
+		};
+	}
+};
+var ValidatorError = class extends Error {
+	constructor(errors) {
+		super(`${errors[0].path ? errors[0].path + ": " : ""}${errors[0].message}`), _define_property(this, "errors", void 0), _define_property(this, "name", void 0), this.errors = errors, this.name = "Validation Error";
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/annotated-type.ts
+const COMPLEX_KINDS = new Set([
+	"union",
+	"intersection",
+	"tuple"
+]);
+const NON_PRIMITIVE_KINDS = new Set(["array", "object"]);
+/** Shared validator method reused by all annotated type nodes. */ function validatorMethod(opts) {
+	return new Validator(this, opts);
+}
+function createAnnotatedTypeNode(type, metadata, opts) {
+	return {
+		__is_atscript_annotated_type: true,
+		type,
+		metadata,
+		validator: validatorMethod,
+		id: opts?.id,
+		optional: opts?.optional,
+		ref: opts?.ref
+	};
+}
+function isAnnotatedType(type) {
+	return type && type.__is_atscript_annotated_type;
+}
+function annotate(metadata, key, value, asArray) {
+	if (!metadata) return;
+	if (asArray) if (metadata.has(key)) {
+		const a = metadata.get(key);
+		if (Array.isArray(a)) a.push(value);
+else metadata.set(key, [a, value]);
+	} else metadata.set(key, [value]);
+else metadata.set(key, value);
+}
+function cloneRefProp(parentType, propName) {
+	if (parentType.kind !== "object") return;
+	const objType = parentType;
+	const existing = objType.props.get(propName);
+	if (!existing) return;
+	const clonedType = cloneTypeDef(existing.type);
+	objType.props.set(propName, createAnnotatedTypeNode(clonedType, new Map(existing.metadata), {
+		id: existing.id,
+		optional: existing.optional
+	}));
+}
+function cloneTypeDef(type) {
+	if (type.kind === "object") {
+		const obj = type;
+		const props = new Map();
+		for (const [k, v] of obj.props) props.set(k, createAnnotatedTypeNode(v.type, new Map(v.metadata), {
+			id: v.id,
+			optional: v.optional
+		}));
+		return {
+			kind: "object",
+			props,
+			propsPatterns: [...obj.propsPatterns],
+			tags: new Set(obj.tags)
+		};
+	}
+	if (type.kind === "array") {
+		const arr = type;
+		return {
+			kind: "array",
+			of: arr.of,
+			tags: new Set(arr.tags)
+		};
+	}
+	if (type.kind === "union" || type.kind === "intersection" || type.kind === "tuple") {
+		const complex = type;
+		return {
+			kind: type.kind,
+			items: [...complex.items],
+			tags: new Set(complex.tags)
+		};
+	}
+	return {
+		...type,
+		tags: new Set(type.tags)
+	};
+}
+function defineAnnotatedType(_kind, base) {
+	const kind = _kind || "";
+	const type = base?.type || {};
+	type.kind = kind;
+	if (COMPLEX_KINDS.has(kind)) type.items = [];
+	if (kind === "object") {
+		type.props = new Map();
+		type.propsPatterns = [];
+	}
+	type.tags = new Set();
+	const metadata = base?.metadata || new Map();
+	const payload = {
+		__is_atscript_annotated_type: true,
+		metadata,
+		type,
+		validator: validatorMethod
+	};
+	base = base ? Object.assign(base, payload) : payload;
+	const handle = {
+		$type: base,
+		$def: type,
+		$metadata: metadata,
+		tags(...tags) {
+			for (const tag of tags) this.$def.tags.add(tag);
+			return this;
+		},
+		designType(value) {
+			this.$def.designType = value;
+			return this;
+		},
+		value(value) {
+			this.$def.value = value;
+			return this;
+		},
+		of(value) {
+			this.$def.of = value;
+			return this;
+		},
+		item(value) {
+			this.$def.items.push(value);
+			return this;
+		},
+		prop(name, value) {
+			this.$def.props.set(name, value);
+			return this;
+		},
+		propPattern(pattern, def) {
+			this.$def.propsPatterns.push({
+				pattern,
+				def
+			});
+			return this;
+		},
+		optional(value = true) {
+			this.$type.optional = value;
+			return this;
+		},
+		copyMetadata(fromMetadata, ignore) {
+			for (const [key, value] of fromMetadata.entries()) if (!ignore || !ignore.has(key)) this.$metadata.set(key, value);
+			return this;
+		},
+		refTo(type$1, chain) {
+			if (isAnnotatedType(type$1)) {
+				let newBase = type$1;
+				const typeName = type$1.name || "Unknown";
+				if (chain) for (let i = 0; i < chain.length; i++) {
+					const c = chain[i];
+					if (newBase.type.kind === "object" && newBase.type.props.has(c)) newBase = newBase.type.props.get(c);
+else {
+						const keys = chain.slice(0, i + 1).map((k) => `["${k}"]`).join("");
+						throw new Error(`Can't find prop ${typeName}${keys}`);
+					}
+				}
+				this.$type = createAnnotatedTypeNode(newBase.type, metadata, {
+					id: newBase.id,
+					ref: chain && chain.length > 0 ? {
+						type: () => type$1,
+						field: chain.join(".")
+					} : undefined
+				});
+			} else if (typeof type$1 === "function") {
+				const lazyType = type$1;
+				this.$type = createAnnotatedTypeNode({ kind: "" }, metadata, { ref: {
+					type: lazyType,
+					field: chain ? chain.join(".") : ""
+				} });
+				const node = this.$type;
+				const placeholder = node.type;
+				Object.defineProperty(node, "type", {
+					get() {
+						const t = lazyType();
+						if (!isAnnotatedType(t)) {
+							Object.defineProperty(node, "type", {
+								value: placeholder,
+								writable: false,
+								configurable: true
+							});
+							return placeholder;
+						}
+						let target = t;
+						if (chain) for (const c of chain) if (target.type.kind === "object" && target.type.props.has(c)) target = target.type.props.get(c);
+else return t.type;
+						node.id = chain ? target.id : target.id || t.id;
+						Object.defineProperty(node, "type", {
+							value: target.type,
+							writable: false,
+							configurable: true
+						});
+						return target.type;
+					},
+					configurable: true
+				});
+			} else throw new TypeError(`${type$1} is not annotated type`);
+			return this;
+		},
+		annotate(key, value, asArray) {
+			annotate(this.$metadata, key, value, asArray);
+			return this;
+		},
+		id(value) {
+			this.$type.id = value;
+			return this;
+		}
+	};
+	return handle;
+}
+function isPhantomType(def) {
+	return def.type.kind === "" && def.type.designType === "phantom";
+}
+function isAnnotatedTypeOfPrimitive(t) {
+	if (NON_PRIMITIVE_KINDS.has(t.type.kind)) return false;
+	if (!t.type.kind) return true;
+	if (COMPLEX_KINDS.has(t.type.kind)) {
+		for (const item of t.type.items) if (!isAnnotatedTypeOfPrimitive(item)) return false;
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region packages/typescript/src/traverse.ts
+function forAnnotatedType(def, handlers) {
+	switch (def.type.kind) {
+		case "": {
+			const typed = def;
+			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
+			return handlers.final(typed);
+		}
+		case "object": return handlers.object(def);
+		case "array": return handlers.array(def);
+		case "union": return handlers.union(def);
+		case "intersection": return handlers.intersection(def);
+		case "tuple": return handlers.tuple(def);
+		default: throw new Error(`Unknown type kind "${def.type.kind}"`);
+	}
+}
+
+//#endregion
+//#region packages/typescript/src/json-schema.ts
+/**
+* Detects a discriminator property across union items.
+*
+* Scans all items for object-typed members that share a common property
+* with distinct const/literal values. If exactly one such property exists,
+* it is returned as the discriminator.
+*/ function detectDiscriminator(items) {
+	if (items.length < 2) return null;
+	for (const item of items) if (item.type.kind !== "object") return null;
+	const firstObj = items[0].type;
+	const candidates = [];
+	for (const [propName, propType] of firstObj.props.entries()) if (propType.type.kind === "" && propType.type.value !== undefined) candidates.push(propName);
+	let result = null;
+	for (const candidate of candidates) {
+		const values = new Set();
+		const indexMapping = {};
+		let valid = true;
+		for (let i = 0; i < items.length; i++) {
+			const obj = items[i].type;
+			const prop = obj.props.get(candidate);
+			if (!prop || prop.type.kind !== "" || prop.type.value === undefined) {
+				valid = false;
+				break;
+			}
+			const val = prop.type.value;
+			if (values.has(val)) {
+				valid = false;
+				break;
+			}
+			values.add(val);
+			indexMapping[String(val)] = i;
+		}
+		if (valid) {
+			if (result) return null;
+			result = {
+				propertyName: candidate,
+				indexMapping
+			};
+		}
+	}
+	return result;
+}
+function buildJsonSchema(type) {
+	const defs = {};
+	let hasDefs = false;
+	const buildObject = (d) => {
+		const properties = {};
+		const required = [];
+		for (const [key, val] of d.type.props.entries()) {
+			if (isPhantomType(val)) continue;
+			properties[key] = build(val);
+			if (!val.optional) required.push(key);
+		}
+		const schema$1 = {
+			type: "object",
+			properties
+		};
+		if (required.length > 0) schema$1.required = required;
+		return schema$1;
+	};
+	const build = (def) => {
+		if (def.id && def.type.kind === "object" && def !== type) {
+			const name = def.id;
+			if (!defs[name]) {
+				hasDefs = true;
+				defs[name] = {};
+				defs[name] = buildObject(def);
+			}
+			return { $ref: `#/$defs/${name}` };
+		}
+		const meta = def.metadata;
+		return forAnnotatedType(def, {
+			phantom() {
+				return {};
+			},
+			object(d) {
+				return buildObject(d);
+			},
+			array(d) {
+				const schema$1 = {
+					type: "array",
+					items: build(d.type.of)
+				};
+				const minLength = meta.get("expect.minLength");
+				if (minLength) schema$1.minItems = typeof minLength === "number" ? minLength : minLength.length;
+				const maxLength = meta.get("expect.maxLength");
+				if (maxLength) schema$1.maxItems = typeof maxLength === "number" ? maxLength : maxLength.length;
+				return schema$1;
+			},
+			union(d) {
+				const disc = detectDiscriminator(d.type.items);
+				if (disc) {
+					const oneOf = d.type.items.map(build);
+					const mapping = {};
+					for (const [val, idx] of Object.entries(disc.indexMapping)) {
+						const item = d.type.items[idx];
+						mapping[val] = item.id && defs[item.id] ? `#/$defs/${item.id}` : `#/oneOf/${idx}`;
+					}
+					return {
+						oneOf,
+						discriminator: {
+							propertyName: disc.propertyName,
+							mapping
+						}
+					};
+				}
+				return { anyOf: d.type.items.map(build) };
+			},
+			intersection(d) {
+				return { allOf: d.type.items.map(build) };
+			},
+			tuple(d) {
+				return {
+					type: "array",
+					items: d.type.items.map(build),
+					additionalItems: false
+				};
+			},
+			final(d) {
+				const schema$1 = {};
+				if (d.type.value !== undefined) schema$1.const = d.type.value;
+				if (d.type.designType && d.type.designType !== "any") {
+					schema$1.type = d.type.designType === "undefined" ? "null" : d.type.designType;
+					if (schema$1.type === "number" && meta.get("expect.int")) schema$1.type = "integer";
+				}
+				if (schema$1.type === "string") {
+					if (meta.get("meta.required")) schema$1.minLength = 1;
+					const minLength = meta.get("expect.minLength");
+					if (minLength) schema$1.minLength = typeof minLength === "number" ? minLength : minLength.length;
+					const maxLength = meta.get("expect.maxLength");
+					if (maxLength) schema$1.maxLength = typeof maxLength === "number" ? maxLength : maxLength.length;
+					const patterns = meta.get("expect.pattern");
+					if (patterns?.length) if (patterns.length === 1) schema$1.pattern = patterns[0].pattern;
+else schema$1.allOf = (schema$1.allOf || []).concat(patterns.map((p) => ({ pattern: p.pattern })));
+				}
+				if (schema$1.type === "number" || schema$1.type === "integer") {
+					const min = meta.get("expect.min");
+					if (min) schema$1.minimum = typeof min === "number" ? min : min.minValue;
+					const max = meta.get("expect.max");
+					if (max) schema$1.maximum = typeof max === "number" ? max : max.maxValue;
+				}
+				return schema$1;
+			}
+		});
+	};
+	const schema = build(type);
+	if (hasDefs) return {
+		...schema,
+		$defs: defs
+	};
+	return schema;
+}
+function fromJsonSchema(schema) {
+	const defsSource = schema.$defs || schema.definitions || {};
+	const resolved = new Map();
+	const convert = (s) => {
+		if (!s || Object.keys(s).length === 0) return defineAnnotatedType().designType("any").$type;
+		if (s.$ref) {
+			const refName = s.$ref.replace(/^#\/(\$defs|definitions)\//, "");
+			if (resolved.has(refName)) return resolved.get(refName);
+			if (defsSource[refName]) {
+				const placeholder = defineAnnotatedType().designType("any").$type;
+				resolved.set(refName, placeholder);
+				const type = convert(defsSource[refName]);
+				resolved.set(refName, type);
+				return type;
+			}
+			throw new Error(`Unresolvable $ref: ${s.$ref}`);
+		}
+		if ("const" in s) {
+			const val = s.const;
+			const dt = val === null ? "null" : typeof val;
+			return defineAnnotatedType().designType(dt).value(val).$type;
+		}
+		if (s.enum) {
+			const handle = defineAnnotatedType("union");
+			for (const val of s.enum) {
+				const dt = val === null ? "null" : typeof val;
+				handle.item(defineAnnotatedType().designType(dt).value(val).$type);
+			}
+			return handle.$type;
+		}
+		if (s.anyOf) {
+			const handle = defineAnnotatedType("union");
+			for (const item of s.anyOf) handle.item(convert(item));
+			return handle.$type;
+		}
+		if (s.oneOf) {
+			const handle = defineAnnotatedType("union");
+			for (const item of s.oneOf) handle.item(convert(item));
+			return handle.$type;
+		}
+		if (s.allOf && !s.type) {
+			const handle = defineAnnotatedType("intersection");
+			for (const item of s.allOf) handle.item(convert(item));
+			return handle.$type;
+		}
+		if (Array.isArray(s.type)) {
+			const handle = defineAnnotatedType("union");
+			for (const t of s.type) handle.item(convert({
+				...s,
+				type: t
+			}));
+			return handle.$type;
+		}
+		if (s.type === "object") {
+			const handle = defineAnnotatedType("object");
+			const required = new Set(s.required || []);
+			if (s.properties) for (const [key, propSchema] of Object.entries(s.properties)) {
+				const propType = convert(propSchema);
+				if (!required.has(key)) propType.optional = true;
+				handle.prop(key, propType);
+			}
+			return handle.$type;
+		}
+		if (s.type === "array") {
+			if (Array.isArray(s.items)) {
+				const handle$1 = defineAnnotatedType("tuple");
+				for (const item of s.items) handle$1.item(convert(item));
+				return handle$1.$type;
+			}
+			const itemType = s.items ? convert(s.items) : defineAnnotatedType().designType("any").$type;
+			const handle = defineAnnotatedType("array").of(itemType);
+			if (typeof s.minItems === "number") handle.annotate("expect.minLength", { length: s.minItems });
+			if (typeof s.maxItems === "number") handle.annotate("expect.maxLength", { length: s.maxItems });
+			return handle.$type;
+		}
+		if (s.type === "string") {
+			const handle = defineAnnotatedType().designType("string").tags("string");
+			if (typeof s.minLength === "number") handle.annotate("expect.minLength", { length: s.minLength });
+			if (typeof s.maxLength === "number") handle.annotate("expect.maxLength", { length: s.maxLength });
+			if (s.pattern) handle.annotate("expect.pattern", { pattern: s.pattern }, true);
+			if (s.allOf) {
+				for (const item of s.allOf) if (item.pattern) handle.annotate("expect.pattern", { pattern: item.pattern }, true);
+			}
+			return handle.$type;
+		}
+		if (s.type === "integer") {
+			const handle = defineAnnotatedType().designType("number").tags("number");
+			handle.annotate("expect.int", true);
+			if (typeof s.minimum === "number") handle.annotate("expect.min", { minValue: s.minimum });
+			if (typeof s.maximum === "number") handle.annotate("expect.max", { maxValue: s.maximum });
+			return handle.$type;
+		}
+		if (s.type === "number") {
+			const handle = defineAnnotatedType().designType("number").tags("number");
+			if (typeof s.minimum === "number") handle.annotate("expect.min", { minValue: s.minimum });
+			if (typeof s.maximum === "number") handle.annotate("expect.max", { maxValue: s.maximum });
+			return handle.$type;
+		}
+		if (s.type === "boolean") return defineAnnotatedType().designType("boolean").tags("boolean").$type;
+		if (s.type === "null") return defineAnnotatedType().designType("null").tags("null").$type;
+		return defineAnnotatedType().designType("any").$type;
+	};
+	return convert(schema);
+}
+function mergeJsonSchemas(types) {
+	const mergedDefs = {};
+	const schemas = {};
+	for (const type of types) {
+		const name = type.id;
+		if (!name) throw new Error("mergeJsonSchemas: all types must have an id");
+		const schema = buildJsonSchema(type);
+		if (schema.$defs) {
+			for (const [defName, defSchema] of Object.entries(schema.$defs)) if (!mergedDefs[defName]) mergedDefs[defName] = defSchema;
+			const { $defs: _,...rest } = schema;
+			schemas[name] = rest;
+		} else schemas[name] = schema;
+	}
+	return {
+		schemas,
+		$defs: mergedDefs
+	};
+}
+
+//#endregion
+export { Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, defineAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas };