@atscript/typescript 0.0.1

package/dist/index.mjs

@@ -0,0 +1,990 @@
+import { isArray, isConst, isGroup, isInterface, isPrimitive, isRef, isStructure } from "@atscript/core";
+import path from "path";
+
+//#region packages/typescript/src/codegen/code-printer.ts
+function _define_property$3(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var CodePrinter = class {
+	/**
+	* Write text with NO automatic newline.
+	* If current line is empty, we prepend indentation.
+	*/ write(...text) {
+		if (!this.currentLine) this.currentLine = this.indentString();
+		this.currentLine += text.join("");
+		return this;
+	}
+	/**
+	* Write text and then finalize this line with a newline.
+	* Implemented by calling `write(...)` + push line + reset `currentLine`.
+	*/ writeln(...text) {
+		this.write(...text);
+		this.lines.push(this.currentLine);
+		this.currentLine = "";
+		return this;
+	}
+	/**
+	* Open a block with an opening/closing pair, e.g. "{}" or "()".
+	* By default, places the opening delimiter on the current line (no extra newline).
+	*/ block(pair) {
+		return this.doBlock(pair, false);
+	}
+	/**
+	* Same as `block()`, but adds a newline after writing the opening delimiter.
+	*/ blockln(pair) {
+		return this.doBlock(pair, true);
+	}
+	/**
+	* Close the most recent block. By default, closing delimiter goes on the current line.
+	*/ pop() {
+		return this.doPop(false);
+	}
+	/**
+	* Same as `pop()`, but puts the closing delimiter on a new line.
+	*/ popln() {
+		return this.doPop(true);
+	}
+	/**
+	* Increase indentation by one level.
+	*/ indent() {
+		this.indentLevel++;
+		return this;
+	}
+	/**
+	* Decrease indentation by one level (never below 0).
+	*/ unindent() {
+		this.indentLevel = Math.max(0, this.indentLevel - 1);
+		return this;
+	}
+	render() {
+		return this.toString();
+	}
+	/**
+	* Return the entire code as a string. Removes any half-finished current line if empty.
+	*/ toString() {
+		if (this.currentLine.trim() !== "") this.lines.push(this.currentLine);
+else if (this.currentLine.length > 0) this.lines.push(this.currentLine);
+		return this.lines.join("\n");
+	}
+	doBlock(pair, withNewLine) {
+		if (pair.length < 2) throw new Error(`Block pair must have at least 2 chars, e.g. "{}" or "()". Got "${pair}"`);
+		const opening = pair[0];
+		const closing = pair[pair.length - 1];
+		this.write(opening);
+		this.blockStack.push(closing);
+		if (withNewLine) this.writeln();
+		this.indent();
+		return this;
+	}
+	doPop(withNewLine) {
+		if (!this.blockStack.length) throw new Error("No block to pop (stack is empty).");
+		const closing = this.blockStack.pop();
+		this.unindent();
+		if (withNewLine) this.writeln(closing);
+else this.write(closing);
+		return this;
+	}
+	indentString() {
+		return " ".repeat(this.indentLevel * this.indentSize);
+	}
+	constructor() {
+		_define_property$3(this, "lines", []);
+		_define_property$3(this, "currentLine", "");
+		_define_property$3(this, "indentLevel", 0);
+		_define_property$3(this, "indentSize", 2);
+		_define_property$3(this, "blockStack", []);
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/codegen/base-renderer.ts
+function _define_property$2(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var BaseRenderer = class extends CodePrinter {
+	pre() {}
+	post() {}
+	render() {
+		this.pre();
+		for (const node of this.doc.nodes) this.renderNode(node);
+		this.post();
+		return this.toString();
+	}
+	renderInterface(node) {}
+	renderType(node) {}
+	transformFromPath(path$1) {
+		return path$1 + ".as";
+	}
+	renderImport(node) {
+		const def = node.getDefinition();
+		const refs = [];
+		const from = this.transformFromPath(node.token("path").text);
+		let isUnusedImport = true;
+		if (isGroup(def)) {
+			for (const child of def.unwrap()) if (isRef(child) && !this.unused.has(child.id)) {
+				const node$1 = child;
+				refs.push(node$1.id);
+				isUnusedImport = false;
+			}
+		} else if (isRef(def) && !this.unused.has(def.id)) {
+			refs.push(def.id);
+			isUnusedImport = false;
+		}
+		if (!isUnusedImport) this.writeln(`import { ${refs.join(", ")} } from "${from}"`);
+	}
+	renderNode(node) {
+		switch (node.entity) {
+			case "interface": {
+				this.renderInterface(node);
+				break;
+			}
+			case "type": {
+				this.renderType(node);
+				break;
+			}
+			case "import": {
+				this.renderImport(node);
+				break;
+			}
+			default: break;
+		}
+	}
+	constructor(doc) {
+		super(), _define_property$2(this, "doc", void 0), _define_property$2(this, "unused", void 0), this.doc = doc;
+		this.unused = new Set(this.doc.getUnusedTokens().map((t) => t.text));
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/codegen/utils.ts
+function wrapProp(name) {
+	const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+	if (!validIdentifier.test(name)) return `"${escapeQuotes(name)}"`;
+	return name;
+}
+function escapeQuotes(str) {
+	return str.replace(/"/g, "\\\"");
+}
+
+//#endregion
+//#region packages/typescript/src/codegen/type-renderer.ts
+var TypeRenderer = class extends BaseRenderer {
+	pre() {
+		this.writeln("// prettier-ignore-start");
+		this.writeln("/* eslint-disable */");
+		this.writeln(`/// <reference path="./${this.doc.name}" />`);
+		this.writeln("/**");
+		this.writeln(" * 🪄 This file was generated by Atscript");
+		this.writeln(" * Do not edit this file!");
+		this.writeln(" */");
+		this.writeln();
+		this.writeln("import type { TAtscriptTypeObject, TAtscriptTypeComplex, TAtscriptTypeFinal, TAtscriptTypeArray, TMetadataMap, Validator } from \"@atscript/typescript\"");
+	}
+	post() {
+		this.writeln("// prettier-ignore-end");
+	}
+	renderTypeDef(def) {
+		if (!def) {
+			this.write("unknown");
+			return;
+		}
+		if (isStructure(def)) return this.renderStructure(def);
+		if (isGroup(def)) {
+			const tuple = def.entity === "tuple";
+			const operator = tuple ? ", " : ` ${def.op} `;
+			const children = def.unwrap();
+			const hasSubgroup = !tuple && children.some((c) => c.entity === "group");
+			this.write(tuple ? "[" : hasSubgroup ? "(" : "");
+			this.renderTypeDef(def.first);
+			for (const child of children.slice(1)) {
+				this.write(operator);
+				this.renderTypeDef(child);
+			}
+			return this.write(tuple ? "]" : hasSubgroup ? ")" : "");
+		}
+		if (isConst(def)) {
+			const name = def.token("identifier")?.type === "number" ? def.id : `"${escapeQuotes(def.id)}"`;
+			return this.write(name);
+		}
+		if (isRef(def)) {
+			const node = def;
+			const unwound = this.doc.unwindType(node.id, node.chain);
+			if (isPrimitive(unwound?.def)) {
+				this.write(renderPrimitiveTypeDef(unwound.def.config.type));
+				if (node.hasChain) this.write(` /* ${node.chain.map((c) => c.text).join(".")} */`);
+				return;
+			}
+			let name = node.id;
+			for (const c of node.chain) name += `["${escapeQuotes(c.text)}"]`;
+			return this.write(name);
+		}
+		if (isArray(def)) {
+			const node = def;
+			const def2 = node.getDefinition();
+			const isGrp = def2?.entity === "group";
+			if (isGrp) this.write("(");
+			this.renderTypeDef(def2);
+			if (isGrp) this.write(")");
+			return this.write("[]");
+		}
+	}
+	renderStructure(struct, asClass) {
+		this.blockln("{}");
+		for (const prop of Array.from(struct.props.values())) {
+			const optional = !!prop.token("optional");
+			this.write(wrapProp(prop.id), optional ? "?" : "", ": ");
+			this.renderTypeDef(prop.getDefinition());
+			this.writeln();
+		}
+		if (asClass) {
+			this.writeln("static __is_anscript_annotated_type: true");
+			this.writeln(`static type: TAtscriptTypeObject<keyof ${asClass}>`);
+			this.writeln(`static metadata: TMetadataMap<AtscriptMetadata>`);
+			this.writeln(`static validator: () => Validator`);
+		}
+		this.pop();
+	}
+	renderInterface(node) {
+		this.writeln();
+		const exported = node.token("export")?.text === "export";
+		this.renderJsDoc(node);
+		this.write(exported ? "export declare " : "declare ");
+		this.write(`class ${node.id} `);
+		const struct = node.getDefinition();
+		if (struct?.entity === "structure") this.renderStructure(struct, node.id);
+else this.writeln("{}");
+		this.writeln();
+	}
+	renderType(node) {
+		this.writeln();
+		const exported = node.token("export")?.text === "export";
+		this.renderJsDoc(node);
+		this.write(exported ? "export " : "declare ");
+		this.write(`type ${node.id} = `);
+		this.renderTypeDef(node.getDefinition());
+		this.writeln();
+		this.renderTypeNamespace(node);
+	}
+	renderTypeNamespace(node) {
+		this.write(`declare namespace ${node.id} `);
+		this.blockln("{}");
+		const def = node.getDefinition();
+		let typeDef = "TAtscriptTypeDef";
+		if (def) {
+			let realDef = def;
+			if (isRef(def)) realDef = this.doc.unwindType(def.id, def.chain)?.def || realDef;
+			realDef = this.doc.mergeIntersection(realDef);
+			if (isStructure(realDef) || isInterface(realDef)) typeDef = `TAtscriptTypeObject<keyof ${node.id}}>`;
+else if (isGroup(realDef)) typeDef = "TAtscriptTypeComplex";
+else if (isArray(realDef)) typeDef = "TAtscriptTypeArray";
+else if (isPrimitive(realDef)) typeDef = "TAtscriptTypeFinal";
+		}
+		this.writeln(`const __is_anscript_annotated_type: true`);
+		this.writeln(`const type: ${typeDef}`);
+		this.writeln(`const metadata: TMetadataMap<AtscriptMetadata>`);
+		this.writeln(`const validator: () => Validator`);
+		this.popln();
+	}
+	renderJsDoc(node) {
+		const range = node.token("identifier")?.range;
+		const rangeStr = range ? `:${range.start.line + 1}:${range.start.character + 1}` : "";
+		this.writeln(`/**`);
+		this.writeln(` * Atscript ${node.entity} **${node.id}**`);
+		this.writeln(` * @see {@link ./${this.doc.name}${rangeStr}}`);
+		this.writeln(` */`);
+	}
+};
+function renderPrimitiveTypeDef(def) {
+	if (!def) return "unknown";
+	if (typeof def === "string") return def === "void" ? "undefined" : def;
+	switch (def.kind) {
+		case "final": return def.value === "void" ? "undefined" : def.value;
+		case "union": return def.items.map(renderPrimitiveTypeDef).join(" | ");
+		case "intersection": return def.items.map(renderPrimitiveTypeDef).join(" & ");
+		case "tuple": return `[${def.items.map(renderPrimitiveTypeDef).join(", ")}]`;
+		case "array": return `${renderPrimitiveTypeDef(def.of)}[]`;
+		case "object": {
+			const props = Object.entries(def.props).map(([key, val]) => `${wrapProp(key)}${typeof val === "object" && val.optional ? "?" : ""}: ${renderPrimitiveTypeDef(val)}`).join("; ");
+			return `{ ${props} }`;
+		}
+		default: return "unknown";
+	}
+}
+
+//#endregion
+//#region packages/typescript/src/codegen/js-renderer.ts
+function _define_property$1(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var JsRenderer = class extends BaseRenderer {
+	pre() {
+		this.writeln("import { defineAnnotatedType as $ } from \"@atscript/typescript\"");
+	}
+	post() {
+		for (const node of this.postAnnotate) {
+			this.annotateType(node.getDefinition(), node.id);
+			this.indent().defineMetadata(node).unindent();
+			this.writeln();
+		}
+		super.post();
+	}
+	renderInterface(node) {
+		this.writeln();
+		const exported = node.token("export")?.text === "export";
+		this.write(exported ? "export " : "");
+		this.write(`class ${node.id} `);
+		this.blockln("{}");
+		this.writeln("static __is_anscript_annotated_type = true");
+		this.writeln("static type = {}");
+		this.writeln("static metadata = new Map()");
+		this.popln();
+		this.postAnnotate.push(node);
+		this.writeln();
+	}
+	renderType(node) {
+		this.writeln();
+		const exported = node.token("export")?.text === "export";
+		this.write(exported ? "export " : "");
+		this.write(`class ${node.id} `);
+		this.blockln("{}");
+		this.writeln("static __is_anscript_annotated_type = true");
+		this.writeln("static type = {}");
+		this.writeln("static metadata = new Map()");
+		this.popln();
+		this.postAnnotate.push(node);
+		this.writeln();
+	}
+	annotateType(_node, name) {
+		if (!_node) return this;
+		const node = this.doc.mergeIntersection(_node);
+		let kind = node.entity;
+		switch (node.entity) {
+			case "ref": {
+				const ref = node;
+				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
+				if (isPrimitive(decl)) {
+					this.annotateType(decl, name);
+					return this;
+				}
+				const chain = ref.hasChain ? `, [${ref.chain.map((c) => `"${escapeQuotes(c.text)}"`).join(", ")}]` : "";
+				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${ref.id}${chain})`).unindent();
+				return this;
+			}
+			case "primitive": {
+				this.definePrimitive(node, name);
+				return this;
+			}
+			case "const": {
+				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().defineConst(node).unindent();
+				return this;
+			}
+			case "structure": {
+				this.writeln(`$("object"${name ? `, ${name}` : ""})`).indent().defineObject(node).unindent();
+				return this;
+			}
+			case "group": {
+				kind = node.op === "|" ? "union" : "intersection";
+				this.writeln(`$("${kind}"${name ? `, ${name}` : ""})`).indent().defineGroup(node).unindent();
+				return this;
+			}
+			case "tuple": {
+				this.writeln(`$("tuple"${name ? `, ${name}` : ""})`).indent().defineGroup(node).unindent();
+				return this;
+			}
+			case "array": {
+				this.writeln(`$("array"${name ? `, ${name}` : ""})`).indent().defineArray(node).unindent();
+				return this;
+			}
+			default: {
+				console.log("!!!!!!! UNKNOWN ", node.entity);
+				return this;
+			}
+		}
+	}
+	defineConst(node) {
+		const t = node.token("identifier")?.type;
+		const designType = t === "text" ? "string" : t === "number" ? "number" : "unknown";
+		const type = t === "text" ? "String" : t === "number" ? "Number" : "undefined";
+		this.writeln(`.designType("${escapeQuotes(designType)}")`);
+		this.writeln(`.value(${t === "text" ? `"${escapeQuotes(node.id)}"` : node.id})`);
+		return this;
+	}
+	definePrimitive(node, name) {
+		this.renderPrimitiveDef(node.id === "never" ? "never" : node.config.type, name);
+		this.writeln(`  .tags(${Array.from(node.tags).map((f) => `"${escapeQuotes(f)}"`).join(", ")})`);
+		return this;
+	}
+	renderPrimitiveDef(def, name) {
+		const d = (t) => [`"${t || ""}"`, name].filter(Boolean).join(", ").replace(/^""$/, "");
+		if (!def) return this.writeln(`$(${d()}).designType("any")`);
+		if (typeof def === "string") return this.writeln(`$(${d()}).designType("${def === "void" ? "undefined" : def}")`);
+		switch (def.kind) {
+			case "final": return this.writeln(`$(${d()}).designType("${def.value === "void" ? "undefined" : def.value}")`);
+			case "union":
+			case "intersection":
+			case "tuple":
+				this.writeln(`$(${d(def.kind)})`);
+				this.indent();
+				for (const itemDef of def.items) {
+					this.write(`.item(`);
+					this.indent();
+					this.renderPrimitiveDef(itemDef);
+					this.writeln(".$type");
+					this.unindent();
+					this.write(`)`);
+				}
+				this.unindent();
+				return;
+			case "array":
+				this.writeln(`$(${d("array")})`);
+				this.indent();
+				this.write(".of(");
+				this.indent();
+				this.renderPrimitiveDef(def.of);
+				this.writeln(`.$type`);
+				this.unindent();
+				this.writeln(`)`);
+				this.unindent();
+				return;
+			case "object":
+				this.writeln(`$(${d("object")})`);
+				this.indent();
+				for (const [key, propDef] of Object.entries(def.props)) {
+					const optional = typeof propDef === "object" && propDef.optional;
+					this.writeln(`.prop(`);
+					this.indent();
+					this.writeln(`"${escapeQuotes(key)}",`);
+					this.renderPrimitiveDef(propDef);
+					if (optional) this.writeln(".optional()");
+					this.writeln(".$type");
+					this.unindent();
+					this.write(`)`);
+				}
+				this.unindent();
+				return;
+			default: return this.writeln(`$(${d()}).designType("any")`);
+		}
+	}
+	defineObject(node) {
+		const props = Array.from(node.props.values());
+		for (const prop of props) {
+			const optional = !!prop.token("optional");
+			this.writeln(`.prop(`);
+			this.indent();
+			this.writeln(`"${escapeQuotes(prop.id)}",`);
+			this.annotateType(prop.getDefinition());
+			this.indent().defineMetadata(prop).unindent();
+			if (optional) this.writeln("  .optional()");
+			this.writeln("  .$type");
+			this.unindent();
+			this.write(`)`);
+		}
+		this.writeln();
+		return this;
+	}
+	defineGroup(node) {
+		const items = node.unwrap();
+		for (const item of items) this.write(".item(").indent().annotateType(item).write("  .$type").writeln(`)`).unindent();
+		return this;
+	}
+	defineArray(node) {
+		this.write(".of(").indent().annotateType(node.getDefinition()).write("  .$type").writeln(`)`).unindent();
+		return this;
+	}
+	defineMetadata(node) {
+		const annotations = this.doc.evalAnnotationsForNode(node);
+		annotations?.forEach((an) => {
+			this.resolveAnnotationValue(node, an);
+		});
+		return this;
+	}
+	resolveAnnotationValue(node, an) {
+		const spec = this.doc.resolveAnnotation(an.name);
+		let targetValue = "true";
+		let multiple = false;
+		if (spec) {
+			multiple = spec.config.multiple;
+			const length = spec.arguments.length;
+			if (length !== 0) if (Array.isArray(spec.config.argument)) {
+				targetValue = "{ ";
+				let i = 0;
+				for (const aSpec of spec.arguments) {
+					if (an.args[i]) targetValue += `${wrapProp(aSpec.name)}: ${aSpec.type === "string" ? `"${escapeQuotes(an.args[i]?.text)}"` : an.args[i]?.text}${i === length - 1 ? "" : ", "} `;
+else {}
+					i++;
+				}
+				targetValue += "}";
+			} else {
+				const aSpec = spec.arguments[0];
+				if (an.args[0]) targetValue = aSpec.type === "string" ? `"${escapeQuotes(an.args[0]?.text)}"` : an.args[0]?.text;
+else targetValue = "true";
+			}
+		} else {
+			multiple = node.countAnnotations(an.name) > 1 || an.args.length > 1;
+			if (an.args.length) targetValue = an.args[0].type === "text" ? `"${escapeQuotes(an.args[0].text)}"` : an.args[0].text;
+		}
+		if (multiple) this.writeln(`.annotate("${escapeQuotes(an.name)}", ${targetValue}, true)`);
+else this.writeln(`.annotate("${escapeQuotes(an.name)}", ${targetValue})`);
+	}
+	constructor(...args) {
+		super(...args), _define_property$1(this, "postAnnotate", []);
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/plugin.ts
+const tsPlugin = () => {
+	return {
+		name: "typesccript",
+		render(doc, format) {
+			if (format === "dts") return [{
+				fileName: `${doc.name}.d.ts`,
+				content: new TypeRenderer(doc).render()
+			}];
+			if (format === "js") return [{
+				fileName: `${doc.name}.js`,
+				content: new JsRenderer(doc).render()
+			}];
+		},
+		async buildEnd(output, format, repo) {
+			if (format === "dts") {
+				const annotations = await repo.getUsedAnnotations();
+				const tags = await repo.getPrimitivesTags() || new Set();
+				let rendered = [];
+				for (const [key, val] of Object.entries(annotations)) {
+					const multiple = val.multiple;
+					let typeLine = Array.from(val.types).map((t) => {
+						if (t.type === "object") return `{ ${Object.entries(t.props).map(([k, v]) => `${wrapProp(k)}${v.optional ? "?" : ""}: ${v.type}`).join(", ")} }`;
+else return t.optional ? `${t.type} | true` : t.type;
+					}).join(" | ");
+					rendered.push(`${wrapProp(key)}: ${multiple ? "(" : ""}${typeLine}${multiple ? ")[]" : ""}`);
+				}
+				let renderedTags = Array.from(tags).map((f) => `"${escapeQuotes(f)}"`).join(" | ");
+				output.push({
+					content: "/**\n * 🪄 This file was generated by Atscript\n * It is generated based on annotations used in this project\n * Do not edit this file!\n *\n * Use `npx asc -f dts` command to re-generate this file\n */\nexport {}\n\ndeclare global {\n  interface AtscriptMetadata {\n    " + rendered.join("\n    ") + "\n  }\n" + "  type AtscriptPrimitiveTags = " + renderedTags + "\n" + "}\n",
+					fileName: "atscript.d.ts",
+					source: "",
+					target: path.join(repo.root, "atscript.d.ts")
+				});
+			}
+		}
+	};
+};
+
+//#endregion
+//#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) return this.stackErrors[this.stackErrors.length - 1].length >= this.opts.errorLimit;
+		return this.errors.length >= this.opts.errorLimit;
+	}
+	push(name) {
+		this.stackPath.push(name);
+		this.stackErrors.push([]);
+	}
+	pop(saveErrors) {
+		this.stackPath.pop();
+		const popped = this.stackErrors.pop();
+		if (saveErrors && popped?.length) popped.forEach((error) => {
+			this.error(error.message, error.path, error.details);
+		});
+		return popped;
+	}
+	clear() {
+		this.stackErrors[this.stackErrors.length - 1] = [];
+	}
+	error(message, path$1, details) {
+		const errors = this.stackErrors[this.stackErrors.length - 1] || this.errors;
+		const error = {
+			path: path$1 || this.stackPath.join(".").slice(1),
+			message
+		};
+		if (details?.length) error.details = details;
+		errors.push(error);
+	}
+	throw() {
+		throw new ValidatorError(this.errors);
+	}
+	validate(value, safe) {
+		this.push("");
+		this.errors = [];
+		this.stackErrors = [];
+		const passed = this._validate(this.def, value);
+		this.pop(!passed);
+		if (!passed) {
+			if (safe) return false;
+			this.throw();
+		}
+		return true;
+	}
+	_validate(def, value) {
+		if (this.isLimitExceeded()) return false;
+		if (!isAnnotatedType(def)) throw new Error("Can not validate not-annotated type");
+		if (def.optional && value === undefined) return true;
+		switch (def.type.kind) {
+			case "object": return this.validateObject(def, value);
+			case "union": return this.validateUnion(def, value);
+			case "intersection": return this.validateIntersection(def, value);
+			case "tuple": return this.validateTuple(def, value);
+			case "array": return this.validateArray(def, value);
+			case "": return this.validatePrimitive(def, value);
+			default: throw new Error(`Unknown type "${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._validate(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._validate(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(`[${i}]`);
+			if (!this._validate(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 (typeof minLength === "number" && value.length < minLength) {
+			this.error(`Expected minimum length of ${minLength} items, got ${value.length} items`);
+			return false;
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (typeof maxLength === "number" && value.length > maxLength) {
+			this.error(`Expected maximum length of ${maxLength} items, got ${value.length} items`);
+			return false;
+		}
+		let i = 0;
+		let passed = true;
+		for (const item of value) {
+			this.push(`[${i}]`);
+			if (!this._validate(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();
+		for (const [key, item] of def.type.props.entries()) {
+			typeKeys.add(key);
+			if (value[key] === undefined) {
+				if (this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
+			}
+			this.push(key);
+			if (this._validate(item, value[key])) this.pop(false);
+else {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			}
+		}
+		for (const key of valueKeys) if (this.opts.unknwonProps !== "ignore") {
+			if (!typeKeys.has(key)) {
+				if (this.opts.unknwonProps === "error") {
+					this.push(key);
+					this.error(`Unexpected property`);
+					this.pop(true);
+					if (this.isLimitExceeded()) return false;
+					passed = false;
+				} else if (this.opts.unknwonProps === "strip") delete value[key];
+			}
+		}
+		return passed;
+	}
+	validatePrimitive(def, value) {
+		if (typeof 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 true;
+			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 minLength = def.metadata.get("expect.minLength");
+		if (typeof minLength === "number" && value.length < minLength) {
+			this.error(`Expected minimum length of ${minLength} characters, got ${value.length} characters`);
+			return false;
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (typeof maxLength === "number" && value.length > maxLength) {
+			this.error(`Expected maximum length of ${maxLength} characters, got ${value.length} characters`);
+			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 (typeof int === "boolean" && int && value % 1 !== 0) {
+			this.error(`Expected integer, got ${value}`);
+			return false;
+		}
+		const min = def.metadata.get("expect.min");
+		if (typeof min === "number" && value < min) {
+			this.error(`Expected minimum ${min}, got ${value}`);
+			return false;
+		}
+		const max = def.metadata.get("expect.max");
+		if (typeof max === "number" && value > max) {
+			this.error(`Expected maximum ${max}, got ${value}`);
+			return false;
+		}
+		return true;
+	}
+	constructor(def, opts) {
+		_define_property(this, "def", void 0);
+		_define_property(this, "opts", void 0);
+		_define_property(this, "errors", void 0);
+		_define_property(this, "stackErrors", void 0);
+		_define_property(this, "stackPath", void 0);
+		this.def = def;
+		this.errors = [];
+		this.stackErrors = [];
+		this.stackPath = [];
+		this.opts = {
+			partial: false,
+			unknwonProps: "error",
+			errorLimit: 10,
+			...opts
+		};
+	}
+};
+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
+function isAnnotatedType(type) {
+	return type && type.__is_anscript_annotated_type;
+}
+function defineAnnotatedType(_kind, base) {
+	const kind = _kind || "";
+	const type = base?.type || {};
+	type.kind = kind;
+	if ([
+		"union",
+		"intersection",
+		"tuple"
+	].includes(kind)) type.items = [];
+	if (kind === "object") type.props = new Map();
+	type.tags = new Set();
+	const metadata = base?.metadata || new Map();
+	if (base) Object.assign(base, {
+		__is_anscript_annotated_type: true,
+		metadata,
+		type,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	});
+else base = {
+		__is_anscript_annotated_type: true,
+		metadata,
+		type,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	};
+	const handle = {
+		$type: base,
+		$def: type,
+		$metadata: metadata,
+		_existingObject: undefined,
+		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;
+		},
+		optional() {
+			this.$type.optional = true;
+			return this;
+		},
+		refTo(type$1, chain) {
+			let newBase = type$1;
+			const typeName = type$1.name || "Unknown";
+			if (isAnnotatedType(newBase)) {
+				let keys = "";
+				for (const c of chain || []) {
+					keys += `["${c}"]`;
+					if (newBase.type.kind === "object") newBase = newBase.type.props.get(c);
+else throw new Error(`Can't find prop ${typeName}${keys}`);
+				}
+				if (!newBase && keys) throw new Error(`Can't find prop ${typeName}${keys}`);
+else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
+				this.$type = {
+					__is_anscript_annotated_type: true,
+					type: newBase.type,
+					metadata,
+					validator(opts) {
+						return new Validator(this, opts);
+					}
+				};
+			} else throw new Error(`${type$1} is not annotated type`);
+			return this;
+		},
+		annotate(key, value, asArray) {
+			if (asArray) if (this.$metadata.has(key)) {
+				const a = this.$metadata.get(key);
+				if (Array.isArray(a)) a.push(value);
+else this.$metadata.set(key, [a, value]);
+			} else this.$metadata.set(key, [value]);
+else this.$metadata.set(key, value);
+			return this;
+		}
+	};
+	return handle;
+}
+
+//#endregion
+//#region packages/typescript/src/index.ts
+var src_default = tsPlugin;
+
+//#endregion
+export { Validator, ValidatorError, src_default as default, defineAnnotatedType, isAnnotatedType };