@atscript/core 0.0.1

package/dist/index.mjs

@@ -0,0 +1,3397 @@
+import fs from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { rolldown } from "rolldown";
+import { BasicNode } from "@prostojs/parser";
+import path$1 from "path";
+import { URL } from "url";
+import { defu } from "defu";
+import { glob } from "glob";
+import { mkdir, writeFile } from "fs/promises";
+
+//#region packages/core/src/parser/nodes/semantic-node.ts
+function _define_property$14(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 SemanticNode = class {
+	registerAtDocument(doc) {
+		if (this.definition) this.definition.registerAtDocument(doc);
+		this.annotations?.forEach((val) => {
+			doc.registerAnnotation(val);
+		});
+	}
+	setDocumentation(s) {
+		this._documentation = s;
+	}
+	get documentation() {
+		return this._documentation;
+	}
+	get id() {
+		return this.token("identifier")?.text;
+	}
+	get referredIdentifiers() {
+		if (isGroup(this)) return this.getIdentifiersRecursive(this);
+		return this.definition ? this.getIdentifiersRecursive(this.definition) : [];
+	}
+	getIdentifiersRecursive(node) {
+		if (isGroup(node)) {
+			const r = [];
+			for (const n of node.unwrap()) r.push(...this.getIdentifiersRecursive(n));
+			return r;
+		} else return node.referredIdentifiers;
+	}
+	countAnnotations(name) {
+		return this.annotationsCounter?.get(name) ?? 0;
+	}
+	annotate(name, token) {
+		if (!this.annotations) this.annotations = [];
+		if (!this.annotationsCounter) this.annotationsCounter = new Map();
+		if (this.annotationsCounter.has(name)) this.annotationsCounter.set(name, this.annotationsCounter.get(name) + 1);
+else this.annotationsCounter.set(name, 1);
+		token.parentNode = this;
+		const a = {
+			name,
+			token,
+			args: []
+		};
+		this.annotations.push(a);
+		return (arg) => {
+			arg.parentNode = this;
+			arg.index = a.args.length;
+			arg.annotationRef = token;
+			a.args.push(arg);
+		};
+	}
+	get length() {
+		return 0;
+	}
+	define(node) {
+		this.definition = node;
+		return this;
+	}
+	get def() {
+		return this.definition;
+	}
+	get identifier() {
+		return this.token("identifier")?.text;
+	}
+	saveToken(token, semantic) {
+		if (!this.tokens) this.tokens = new Map();
+		token.parentNode = this;
+		this.tokens.set(semantic, token);
+		return this;
+	}
+	wrap(node, token) {
+		this.define(node);
+		this.saveToken(token, "identifier");
+		return this;
+	}
+	token(s) {
+		return this.tokens?.get(s);
+	}
+	has(s) {
+		return this.tokens?.has(s);
+	}
+	toString(level = 0, prefix = "●") {
+		const indent = " ".repeat(level * 2);
+		let s = `${this.renderAnnotations()}${prefix} [${this.entity}] "${this.token("identifier")?.text ?? ""}"`;
+		this.tokens?.forEach((t, key) => {
+			s += key === "identifier" ? "" : ` ${key}: ${t.text} <${t.type}>`;
+		});
+		s += this.renderChildren();
+		return indent + s.split("\n").join(`\n${indent}`);
+	}
+	renderAnnotations() {
+		if (this.annotations) return `${this.annotations?.map(({ token, args }) => `${token.text} ${args.map((a) => a.type === "text" ? `"${a.text}"` : a.text).join(" ")}`).join("\n")}\n`;
+		return "";
+	}
+	renderChildren() {
+		if (this.definition) return isGroup(this.definition) ? `\n${this.definition.toString(1, "=")}\n` : `${this.definition.toString(0, ":")}`;
+		return "";
+	}
+	getDefinition() {
+		return this.definition;
+	}
+	constructor(entity) {
+		_define_property$14(this, "entity", void 0);
+		_define_property$14(this, "tokens", void 0);
+		_define_property$14(this, "isGroup", void 0);
+		_define_property$14(this, "definition", void 0);
+		_define_property$14(this, "annotations", void 0);
+		_define_property$14(this, "annotationsCounter", void 0);
+		_define_property$14(this, "_documentation", void 0);
+		this.entity = entity;
+		this.isGroup = false;
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/array-node.ts
+var SemanticArrayNode = class extends SemanticNode {
+	get props() {
+		if (this.definition) return isStructure(this.definition) ? this.definition.props : new Map();
+		return new Map();
+	}
+	constructor() {
+		super("array");
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/const-node.ts
+var SemanticConstNode = class extends SemanticNode {
+	registerAtDocument(doc) {
+		const token = this.token("identifier");
+		if (token && token.type === "text" && token.multiline) doc.registerMessage(token, "Unexpected end of string");
+	}
+	constructor() {
+		super("const");
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/group-node.ts
+function _define_property$13(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 SemanticGroup = class extends SemanticNode {
+	registerAtDocument(doc) {
+		if (this.nodes.length > 0) this.unwrap().forEach((n) => n.registerAtDocument(doc));
+	}
+	get length() {
+		return this.nodes.length;
+	}
+	get first() {
+		return this.nodes[0];
+	}
+	get op() {
+		return this.operator;
+	}
+	define(node) {
+		if (isGroup(node)) {
+			this.nodes = node.unwrap();
+			this.operator = node.op;
+		} else this.nodes = [node];
+		return this;
+	}
+	wrap(node, token) {
+		node.define(this);
+		node.saveToken(token, "identifier");
+		return this;
+	}
+	unwrap() {
+		return this.nodes;
+	}
+	renderChildren() {
+		let s = "  (\n";
+		s += this.nodes.map((n) => n.toString(2)).join(` <${this.operator || ""}>\n`);
+		s += "\n  )";
+		return s;
+	}
+	constructor(nodes = [], operator) {
+		super("group"), _define_property$13(this, "nodes", void 0), _define_property$13(this, "operator", void 0), _define_property$13(this, "isGroup", void 0), this.nodes = nodes, this.operator = operator, this.isGroup = true;
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/import-node.ts
+var SemanticImportNode = class extends SemanticNode {
+	registerAtDocument(doc) {
+		const imports = this.definition ? this.getIdentifiersRecursive(this.definition) : [];
+		doc.registerImport({
+			from: this.token("path"),
+			imports,
+			block: this.token("inner")
+		});
+	}
+	constructor() {
+		super("import");
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/interface-node.ts
+var SemanticInterfaceNode = class extends SemanticNode {
+	registerAtDocument(doc) {
+		super.registerAtDocument(doc);
+		const token = this.token("identifier");
+		doc.registerDefinition(token);
+		if (token && this.token("export")) {
+			token.exported = true;
+			doc.registerExport(this);
+		}
+	}
+	get props() {
+		if (this.definition) return isStructure(this.definition) ? this.definition.props : new Map();
+		return new Map();
+	}
+	constructor() {
+		super("interface");
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/token.ts
+function _define_property$12(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 Token = class Token {
+	toString() {
+		const children = this.hasChildren ? ` (${this.children.length})` : "";
+		return `[${this.type}] "${this.text}"${children}`;
+	}
+	clone(replace) {
+		const t = {
+			...this._data,
+			...replace
+		};
+		return new Token(t);
+	}
+	get text() {
+		return this._data.text || "";
+	}
+	get type() {
+		return this._data.type;
+	}
+	get range() {
+		return this._data.getRange();
+	}
+	get children() {
+		return this._data.children || [];
+	}
+	get hasChildren() {
+		return Boolean(this._data.children?.length);
+	}
+	/**
+	* This is truth if the text token was ended with a newline character
+	*/ get multiline() {
+		return this._data.multiline;
+	}
+	get isAnnotation() {
+		return this._data.type === "annotation";
+	}
+	constructor(_data) {
+		_define_property$12(this, "_data", void 0);
+		/**
+		* Set this to file path (e.g. "./src/file.as") for path token in import statement
+		*/ _define_property$12(this, "fromPath", void 0);
+		/**
+		* All definitions that exported must be marked with this flag
+		*/ _define_property$12(this, "exported", void 0);
+		/**
+		* All the definitions must be marked with this flag
+		*/ _define_property$12(this, "isDefinition", void 0);
+		/**
+		* All the references must be marked with this flag
+		*/ _define_property$12(this, "isReference", void 0);
+		/**
+		* All the import tokens must be marked with this flag
+		*/ _define_property$12(this, "imported", void 0);
+		/**
+		* All the props must be marked with this flag
+		*/ _define_property$12(this, "isProp", void 0);
+		/**
+		* Refs chained via . or ["propName"] are marked with this flag
+		*/ _define_property$12(this, "isChain", void 0);
+		_define_property$12(this, "parentNode", void 0);
+		/**
+		* Only for annotation arguments: reference to their annotation token
+		*/ _define_property$12(this, "annotationRef", void 0);
+		_define_property$12(this, "index", void 0);
+		/**
+		* Block type
+		*/ _define_property$12(this, "blockType", void 0);
+		this._data = _data;
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/primitive-node.ts
+function _define_property$11(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 SemanticPrimitiveNode = class SemanticPrimitiveNode extends SemanticNode {
+	applyAnnotations() {
+		this.annotations = [];
+		if (this.type === "string" || this.type === "array") {
+			if (typeof this.config.expect?.minLength === "number") this.annotations.push({
+				name: "expect.minLength",
+				token: dummyToken,
+				args: [num(this.config.expect.minLength)]
+			});
+			if (typeof this.config.expect?.maxLength === "number") this.annotations.push({
+				name: "expect.maxLength",
+				token: dummyToken,
+				args: [num(this.config.expect.maxLength)]
+			});
+		}
+		if (this.type === "string") {
+			if (typeof this.config.expect?.pattern !== "undefined") {
+				const patterns = Array.isArray(this.config.expect.pattern) ? this.config.expect.pattern : [this.config.expect.pattern];
+				for (const p of patterns) {
+					const args = typeof p === "string" ? [text$1(p)] : [text$1(p.source), text$1(p.flags)];
+					if (this.config.expect.message) args[2] = text$1(this.config.expect.message);
+					this.annotations.push({
+						name: "expect.pattern",
+						token: dummyToken,
+						args
+					});
+				}
+			}
+		}
+		if (this.type === "number") {
+			if (typeof this.config.expect?.min === "number") this.annotations.push({
+				name: "expect.min",
+				token: dummyToken,
+				args: [num(this.config.expect.min)]
+			});
+			if (typeof this.config.expect?.max === "number") this.annotations.push({
+				name: "expect.max",
+				token: dummyToken,
+				args: [num(this.config.expect.max)]
+			});
+			if (this.config.expect?.int === true) this.annotations.push({
+				name: "expect.int",
+				token: dummyToken,
+				args: []
+			});
+		}
+	}
+	get key() {
+		return this.parentKey ? `${this.parentKey}.${this._id}` : this._id;
+	}
+	getAllTags(_processed) {
+		const allTags = [this._id];
+		const processed = _processed || new Set();
+		processed.add(this);
+		for (const [, node] of this.props) {
+			if (processed.has(node)) continue;
+			processed.add(node);
+			allTags.push(...node.getAllTags(processed));
+		}
+		return allTags;
+	}
+	get id() {
+		return this._id;
+	}
+	get documentation() {
+		return this.config.documentation ? `**${this.key}** - ${this.config.documentation}` : `**${this.key}**`;
+	}
+	toString(level = 0, prefix = "●") {
+		const indent = " ".repeat(level * 2);
+		let s = `${this.renderAnnotations()}${prefix} [${this.entity}] ${JSON.stringify(this.config.type)}`;
+		s += this.renderChildren();
+		return indent + s.split("\n").join(`\n${indent}`);
+	}
+	constructor(_id, config, parentKey = "") {
+		super("primitive"), _define_property$11(this, "_id", void 0), _define_property$11(this, "config", void 0), _define_property$11(this, "parentKey", void 0), _define_property$11(this, "type", void 0), _define_property$11(this, "props", void 0), _define_property$11(this, "tags", void 0), this._id = _id, this.config = config, this.parentKey = parentKey;
+		this.props = new Map();
+		this.tags = new Set([_id, ...config?.tags || []]);
+		for (const [ext, def] of Object.entries(config.extensions || {})) {
+			const node = new SemanticPrimitiveNode(ext, {
+				type: def.type ?? config.type,
+				documentation: def.documentation ?? config.documentation,
+				extensions: def.extensions,
+				tags: Array.from(new Set([...def.tags || [], ...Array.from(this.tags)])),
+				expect: {
+					...config.expect,
+					...def.expect
+				}
+			}, this.key);
+			this.props.set(ext, node);
+		}
+		if (typeof config.type === "object") this.type = config.type.kind === "final" ? config.type.value : config.type.kind;
+else this.type = config.type;
+		this.applyAnnotations();
+	}
+};
+const dummyToken = new Token({
+	getRange: () => ({
+		end: {
+			character: 0,
+			line: 0
+		},
+		start: {
+			character: 0,
+			line: 0
+		}
+	}),
+	text: "",
+	type: "identifier"
+});
+const num = (val) => new Token({
+	getRange: () => ({
+		end: {
+			character: 0,
+			line: 0
+		},
+		start: {
+			character: 0,
+			line: 0
+		}
+	}),
+	text: val.toString(),
+	type: "number"
+});
+const text$1 = (val) => new Token({
+	getRange: () => ({
+		end: {
+			character: 0,
+			line: 0
+		},
+		start: {
+			character: 0,
+			line: 0
+		}
+	}),
+	text: val,
+	type: "text"
+});
+
+//#endregion
+//#region packages/core/src/parser/nodes/prop-node.ts
+var SemanticPropNode = class extends SemanticNode {
+	registerAtDocument(doc) {
+		super.registerAtDocument(doc);
+		const token = this.token("identifier");
+		if (token && token.type === "text" && token.multiline) doc.registerMessage(token, "Unexpected end of string");
+	}
+	get nestedProps() {
+		if (this.definition && isStructure(this.definition)) return this.definition.props;
+	}
+	get nestedType() {
+		if (this.definition && isRef(this.definition)) return this.definition;
+	}
+	constructor() {
+		super("prop");
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/ref-node.ts
+function _define_property$10(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 SemanticRefNode = class extends SemanticNode {
+	get referredIdentifiers() {
+		return [this.token("identifier")];
+	}
+	registerAtDocument(doc) {
+		super.registerAtDocument(doc);
+		this.token("identifier").index = 0;
+		this._chain.forEach((c) => {
+			doc.tokensIndex.add(c);
+		});
+		this._dots.forEach((d) => {
+			doc.tokensIndex.add(d);
+		});
+	}
+	addChain(token) {
+		token.parentNode = this;
+		token.isChain = true;
+		token.index = this._chain.length + 1;
+		this._chain.push(token);
+	}
+	addDot(token) {
+		token.parentNode = this;
+		token.isChain = true;
+		token.index = this._chain.length;
+		this._dots.push(token);
+	}
+	get chain() {
+		return this._chain;
+	}
+	get hasChain() {
+		return this._chain.length > 0;
+	}
+	toString(level = 0, prefix = "●") {
+		const indent = " ".repeat(level * 2);
+		let s = `${this.renderAnnotations()}${prefix} [${this.entity}] "${this.token("identifier")?.text ?? ""}"`;
+		this.tokens?.forEach((t, key) => {
+			s += key === "identifier" ? "" : ` ${key}: ${t.text} <${t.type}>`;
+		});
+		s += this.hasChain ? `.${this.chain.map((c) => `["${c.text}"]`).join(".")}` : "";
+		return indent + s.split("\n").join(`\n${indent}`);
+	}
+	constructor() {
+		super("ref"), _define_property$10(this, "_chain", []), _define_property$10(this, "_dots", []);
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/structure-node.ts
+function _define_property$9(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 SemanticStructureNode = class extends SemanticGroup {
+	/**
+	* Shortcut to set props, used as utility
+	*/ setProps(props$1) {
+		this.nodes = props$1;
+		for (const prop of props$1) this.props.set(prop.id, prop);
+	}
+	registerAtDocument(doc) {
+		super.registerAtDocument(doc);
+		const block$2 = this.token("identifier");
+		block$2.blockType = "structure";
+		doc.blocksIndex.add(block$2);
+		for (const node of this.nodes) {
+			const token = node.token("identifier");
+			if (!token) {
+				doc.registerMessage(block$2, "Has empty prop node");
+				continue;
+			}
+			const name = token.text;
+			if (typeof name !== "string") {
+				doc.registerMessage(token, "Prop node has no name");
+				continue;
+			}
+			if (this.props.has(name)) {
+				doc.registerMessage(token, "Duplicate prop identifier");
+				continue;
+			}
+			if (!isProp(node)) {
+				doc.registerMessage(token, "Non-prop node");
+				continue;
+			}
+			this.props.set(name, node);
+		}
+	}
+	addVirtualProp(opts) {
+		const token = opts.refToken || this.token("identifier");
+		const propToken = token.clone({
+			type: "identifier",
+			text: opts.name
+		});
+		const prop = new SemanticPropNode();
+		if (opts.documentation) prop.setDocumentation(opts.documentation);
+		prop.saveToken(propToken, "identifier");
+		if (typeof opts.type === "string") {
+			const ref$1 = new SemanticRefNode();
+			const [first, ...rest] = opts.type.split(".");
+			const refToken = token.clone({
+				type: "identifier",
+				text: first
+			});
+			ref$1.saveToken(refToken, "identifier");
+			for (const chain of rest) {
+				const chainToken = token.clone({
+					type: "identifier",
+					text: chain
+				});
+				ref$1.addChain(chainToken);
+			}
+			prop.define(ref$1);
+		} else prop.define(opts.type);
+		this.nodes.push(prop);
+		this.props.set(opts.name, prop);
+	}
+	constructor() {
+		super(), _define_property$9(this, "props", new Map());
+		this.entity = "structure";
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/tuple-node.ts
+var SemanticTupleNode = class extends SemanticGroup {
+	constructor() {
+		super();
+		this.entity = "tuple";
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/type-node.ts
+var SemanticTypeNode = class extends SemanticNode {
+	registerAtDocument(doc) {
+		super.registerAtDocument(doc);
+		const token = this.token("identifier");
+		doc.registerDefinition(token);
+		if (token && this.token("export")) {
+			token.exported = true;
+			doc.registerExport(this);
+		}
+		if (this.definition) {}
+	}
+	constructor() {
+		super("type");
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/nodes/index.ts
+const $n = {
+	SemanticGroup,
+	SemanticInterfaceNode,
+	SemanticTypeNode,
+	SemanticRefNode,
+	SemanticConstNode,
+	SemanticPropNode,
+	SemanticStructureNode,
+	SemanticTupleNode,
+	SemanticArrayNode,
+	SemanticImportNode,
+	SemanticPrimitiveNode
+};
+function isGroup(node) {
+	return node?.entity === "group" || node?.entity === "structure" || node?.entity === "tuple";
+}
+function isInterface(node) {
+	return node?.entity === "interface";
+}
+function isType(node) {
+	return node?.entity === "type";
+}
+function isRef(node) {
+	return node?.entity === "ref";
+}
+function isConst(node) {
+	return node?.entity === "const";
+}
+function isProp(node) {
+	return node?.entity === "prop";
+}
+function isStructure(node) {
+	return node?.entity === "structure";
+}
+function isTuple(node) {
+	return node?.entity === "tuple";
+}
+function isArray(node) {
+	return node?.entity === "array";
+}
+function isImport(node) {
+	return node?.entity === "import";
+}
+function isPrimitive(node) {
+	return node?.entity === "primitive";
+}
+
+//#endregion
+//#region packages/core/src/annotations/annotation-spec.ts
+function _define_property$8(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 AnnotationSpec = class {
+	get arguments() {
+		if (!this.config.argument) return [];
+		return Array.isArray(this.config.argument) ? this.config.argument : [this.config.argument];
+	}
+	get argumentsSnippet() {
+		if (this.arguments.length === 0) return "";
+		return this.arguments.map((arg, index) => {
+			const placeholderIndex = index + 1;
+			const defaultValue = this.getDefaultValueForType(arg.name, arg.type);
+			const quote = arg.type === "string" ? `'` : "";
+			return `${quote}\${${placeholderIndex}:${defaultValue}}${quote}`;
+		}).join(", ");
+	}
+	validateType(tokenType, type$1) {
+		switch (type$1) {
+			case "string": return tokenType === "text" ? undefined : "string expected.";
+			case "number": return tokenType === "number" ? undefined : "number expected.";
+			case "boolean": return tokenType === "identifier" ? undefined : "boolean expected.";
+			default: return `unknown type "${type$1}".`;
+		}
+	}
+	modify(mainToken, args, doc) {
+		if (this.config.modify) this.config.modify(mainToken, args, doc);
+	}
+	validate(mainToken, args, doc) {
+		const messages = [];
+		const specArgs = this.arguments;
+		if (!mainToken.parentNode) return;
+		if (mainToken.parentNode.countAnnotations(mainToken.text.slice(1)) > 1 && !this.config.multiple) messages.push({
+			severity: 1,
+			message: `Multiple "${mainToken.text}" annotations are not allowed.`,
+			range: mainToken.range
+		});
+		if (this.config.nodeType && this.config.nodeType.length > 0 && !this.config.nodeType.includes(mainToken.parentNode.entity)) messages.push({
+			severity: 1,
+			message: `${mainToken.text} applies only to ${this.config.nodeType.join(", ")} nodes.`,
+			range: mainToken.range
+		});
+		const requiredCount = specArgs.filter((a) => !a.optional).length;
+		if (args.length < requiredCount) messages.push({
+			severity: 1,
+			message: `${mainToken.text} requires at least ${requiredCount} arguments, but got ${args.length}.`,
+			range: mainToken.range
+		});
+		if (args.length > specArgs.length) {
+			const i = specArgs.length;
+			messages.push({
+				severity: 1,
+				message: `${mainToken.text} got ${args.length} arguments, expected ${specArgs.length}.`,
+				range: {
+					start: args[i].range.start,
+					end: args[args.length - 1].range.end
+				}
+			});
+		}
+		for (let i = 0; i < args.length; i++) {
+			const token = args[i];
+			if (i >= specArgs.length) break;
+			const argSpec = specArgs[i];
+			const tokenType = token.type;
+			const valueText = token.text;
+			const typeMessage = this.validateType(tokenType, argSpec.type);
+			if (typeMessage) {
+				messages.push({
+					severity: 1,
+					message: `${mainToken.text} at argument #${i + 1}: ${typeMessage}`,
+					range: token.range
+				});
+				continue;
+			}
+			const values = argSpec.type === "boolean" ? ["true", "false"] : argSpec.values;
+			if (values && !values.includes(valueText)) messages.push({
+				severity: 1,
+				message: `${mainToken.text} at argument #${i + 1} ("${argSpec.name}") must be one of [${values.join(", ")}]`,
+				range: token.range
+			});
+			if (this.config.defType?.length) {
+				let def = mainToken.parentNode.getDefinition();
+				if (isRef(def)) def = doc.unwindType(def.id, def.chain)?.def || def;
+				let defEntity = def?.entity || "unknown";
+				if (isInterface(def) || isStructure(def)) defEntity = "object";
+else if (isGroup(def) && def.entity !== "tuple") defEntity = def.op === "&" ? "intersection" : "union";
+				if (!isPrimitive(def) && !this.config.defType.includes(defEntity) || isPrimitive(def) && !this.config.defType.includes(def.type)) messages.push({
+					message: `Expected type is (${this.config.defType.join(" | ")}), got "${isPrimitive(def) ? def.type : def?.entity || "unknown"}"`,
+					severity: 1,
+					range: mainToken.range
+				});
+			}
+		}
+		if (this.config.validate) messages.push(...this.config.validate(mainToken, args, doc) || []);
+		return messages.length > 0 ? messages : undefined;
+	}
+	renderDocs(index) {
+		if (typeof index === "number") {
+			const a = this.arguments[index];
+			if (a) {
+				const values = a.values ? `\n\nValues:\n${a.values.join(", ")}` : "";
+				return `### \`${a.name}${a.optional ? "?" : ""}: ${a.type}\`\n\n${a.description}${values}`;
+			}
+		} else {
+			const args = this.arguments;
+			return `### ${index} ${args.map((a) => `\`${a.name}${a.optional ? "?" : ""}: ${a.type}\``).join(", ")}\n\n${this.config.description}`;
+		}
+	}
+	getDefaultValueForType(name, type$1) {
+		switch (type$1) {
+			case "string": return name;
+			case "number": return "0";
+			case "boolean": return "true";
+			default: return "";
+		}
+	}
+	constructor(config) {
+		_define_property$8(this, "config", void 0);
+		_define_property$8(this, "__is_annotation_spec", void 0);
+		this.config = config;
+		this.__is_annotation_spec = true;
+	}
+};
+function isAnnotationSpec(a) {
+	return Boolean(a) && a.__is_annotation_spec;
+}
+function resolveAnnotation(name, annotationsTree) {
+	const parts = name.split(".");
+	let current = annotationsTree;
+	for (const part of parts) {
+		if (!current || isAnnotationSpec(current)) return undefined;
+		current = current[part];
+	}
+	return isAnnotationSpec(current) ? current : undefined;
+}
+
+//#endregion
+//#region packages/core/src/config/define-config.ts
+function defineConfig(config) {
+	return config;
+}
+
+//#endregion
+//#region packages/core/src/config/load-config.ts
+async function bundleTsConfig(configFile, forceFormat) {
+	const dirnameVarName = "injected_original_dirname";
+	const filenameVarName = "injected_original_filename";
+	const importMetaUrlVarName = "injected_original_import_meta_url";
+	const bundle = await rolldown({
+		input: configFile,
+		platform: "node",
+		resolve: { mainFields: ["main"] },
+		define: {
+			"__dirname": dirnameVarName,
+			"__filename": filenameVarName,
+			"import.meta.url": importMetaUrlVarName,
+			"import.meta.dirname": dirnameVarName,
+			"import.meta.filename": filenameVarName
+		},
+		treeshake: false,
+		external: [/^[\w@][^:]/u],
+		plugins: [{
+			name: "inject-file-scope-variables",
+			transform: {
+				filter: { id: /\.[cm]?[jt]s$/u },
+				handler(code, id) {
+					const injectValues = `const ${dirnameVarName} = ${JSON.stringify(path.dirname(id))};` + `const ${filenameVarName} = ${JSON.stringify(id)};` + `const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(id).href)};`;
+					return {
+						code: injectValues + code,
+						map: null
+					};
+				}
+			}
+		}]
+	});
+	const outputDir = path.dirname(configFile);
+	const result = await bundle.write({
+		dir: outputDir,
+		format: forceFormat || "esm",
+		sourcemap: "inline",
+		entryFileNames: forceFormat === "cjs" ? "atscript.config.[hash].cjs" : "atscript.config.[hash].mjs"
+	});
+	const fileName = result.output.find((chunk) => chunk.type === "chunk" && chunk.isEntry).fileName;
+	return path.join(outputDir, fileName);
+}
+const SUPPORTED_JS_CONFIG_FORMATS = [
+	".js",
+	".mjs",
+	".cjs"
+];
+const SUPPORTED_TS_CONFIG_FORMATS = [
+	".ts",
+	".mts",
+	".cts"
+];
+const SUPPORTED_CONFIG_FORMATS = [...SUPPORTED_JS_CONFIG_FORMATS, ...SUPPORTED_TS_CONFIG_FORMATS];
+const DEFAULT_CONFIG_BASE = "atscript.config";
+async function resolveConfigFile(docUri, _root) {
+	const startDir = docUri.endsWith(".as") ? path.dirname(docUri) : docUri;
+	const root$1 = _root || startDir;
+	let currentDir = startDir;
+	const rootId = "file://" + root$1;
+	while (true) {
+		const candidate = await findConfigFileName(currentDir);
+		if (candidate) return candidate;
+		const parentDir = path.dirname(currentDir);
+		if (currentDir === rootId || parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	return undefined;
+}
+async function findConfigFileName(d) {
+	const p = d.startsWith("file://") ? d.slice(7) : d;
+	const filesInWorkingDirectory = new Set(await readdir(decodeURIComponent(p)));
+	for (const extension of SUPPORTED_CONFIG_FORMATS) {
+		const fileName = `${DEFAULT_CONFIG_BASE}${extension}`;
+		if (filesInWorkingDirectory.has(fileName)) return fileName;
+	}
+}
+async function loadTsConfig(configFile, forceFormat) {
+	const file = await bundleTsConfig(configFile, forceFormat);
+	try {
+		return (await import(pathToFileURL(file).href)).default;
+	} catch (error) {
+		console.error("Could not load config file", file, error);
+		return {};
+	} finally {
+		fs.unlink(file, () => {});
+	}
+}
+async function loadConfig(configPath, forceFormat) {
+	const ext = path.extname(configPath);
+	try {
+		if (SUPPORTED_JS_CONFIG_FORMATS.includes(ext)) return forceFormat ? await loadTsConfig(path.resolve(configPath), forceFormat) : (await import(pathToFileURL(configPath).href)).default;
+else if (SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) {
+			const rawConfigPath = path.resolve(configPath);
+			return await loadTsConfig(rawConfigPath, forceFormat);
+		} else throw new Error(`Unsupported config format. Expected: \`${SUPPORTED_CONFIG_FORMATS.join(",")}\` but got \`${ext}\``);
+	} catch (error) {
+		throw new Error("Error happened while loading config.");
+	}
+}
+
+//#endregion
+//#region packages/core/src/parser/id-registry.ts
+function _define_property$7(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 IdRegistry = class {
+	clear() {
+		this.definitions.clear();
+		this.duplicates.clear();
+		this.forbidden.clear();
+	}
+	registerDefinition(token) {
+		if (!token) return;
+		if (this.reserved.has(token.text)) this.forbidden.add(token);
+else if (this.definitions.has(token.text)) this.duplicates.add(token);
+else this.definitions.set(token.text, token);
+	}
+	isDefined(t) {
+		const text$2 = typeof t === "string" ? t : t.text;
+		return this.definitions.has(text$2) || this.globalTypes.has(text$2);
+	}
+	getErrors() {
+		return [...Array.from(this.duplicates, (t) => ({
+			severity: 1,
+			message: `Duplicate identifier "${t.text}"`,
+			range: t.range
+		})), ...Array.from(this.forbidden, (t) => ({
+			severity: 1,
+			message: `Reserved keyword "${t.text}"`,
+			range: t.range
+		}))];
+	}
+	constructor(globalTypes = []) {
+		_define_property$7(this, "reserved", void 0);
+		_define_property$7(this, "globalTypes", void 0);
+		_define_property$7(this, "definitions", new Map());
+		_define_property$7(this, "duplicates", new Set());
+		_define_property$7(this, "forbidden", new Set());
+		this.reserved = new Set([
+			"interface",
+			"type",
+			"import",
+			"from",
+			"export"
+		].concat(globalTypes));
+		this.globalTypes = new Set(globalTypes);
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/iterator.ts
+function _define_property$6(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 NodeIterator = class NodeIterator {
+	get index() {
+		return this.i;
+	}
+	get lastNode() {
+		return this.nodes[this.nodes.length - 1];
+	}
+	unexpectedEOB() {
+		this.issues.unexpectedEOB = true;
+	}
+	unfork(fork) {
+		this.i = fork.index;
+		this.update();
+	}
+	accepted() {
+		if (this.$ && this.$.accepted !== false) {
+			this.$.accepted = true;
+			this.badNodes.delete(this.$);
+		}
+	}
+	toString() {
+		return this.$ ? `[${this.$.type}] ${this.$.text}` : `void`;
+	}
+	update() {
+		this.$ = this.nodes[this.i];
+		return this;
+	}
+	move(v = 1) {
+		this.i += v;
+		this.$ = this.nodes[this.i];
+		return this;
+	}
+	/** @deprecated */ killNextNode(n = 1) {
+		this.nodes.splice(this.i + 1, n);
+	}
+	next(skip) {
+		return this.fork().move().skip(skip);
+	}
+	fork(nodes) {
+		return new NodeIterator(nodes || this.nodes, this.messages, this.badNodes, this.issues, nodes ? this.$ : this.parent, nodes ? 0 : this.i).update();
+	}
+	skip(pun$1) {
+		while (this.$?.type === "comment" || this.$?.type === "punctuation" && pun$1?.length && pun$1.includes(this.$.text)) this.move();
+		return this;
+	}
+	skipUntil(pun$1) {
+		while (this.$ && !this.satisfies({
+			node: "punctuation",
+			text: pun$1
+		})) this.move();
+	}
+	unexpected(force = false, msg = "Unexpected token") {
+		if (force && this.$) this.$.accepted = false;
+		if (this.$ && !this.badNodes.has(this.$)) this.badNodes.set(this.$, msg);
+	}
+	shouldHaveError(depth) {
+		for (let i = this.i; i <= depth; i++) if (i < this.nodes.length) this.nodes[i].accepted = false;
+	}
+	nodesLeft() {
+		return this.nodes.length > 0 && this.index < this.nodes.length;
+	}
+	satisfies(...rules) {
+		for (const rule of rules) {
+			const passed = Array.isArray(rule.node) ? rule.node.includes(this.$?.type) : this.$?.type === rule.node;
+			if (passed && rule.text === undefined) return true;
+			if (passed && Array.isArray(rule.text) ? rule.text.includes(this.$?.text) : this.$?.text === rule.text) return true;
+		}
+		return false;
+	}
+	confirmIssues() {
+		if (this.issues.unexpectedEOB) {
+			const node = this.lastNode || this.parent;
+			const pos = node?.getRange().end || {
+				character: 1,
+				line: 1
+			};
+			this.messages.push({
+				severity: 1,
+				message: `Unexpected end of block`,
+				range: {
+					start: pos,
+					end: pos
+				}
+			});
+			this.issues.unexpectedEOB = false;
+		}
+	}
+	getErrors() {
+		this.badNodes.forEach((msg, node) => {
+			if (node.accepted) this.badNodes.delete(node);
+		});
+		return Array.from(this.badNodes.entries(), ([node, msg]) => ({
+			severity: 1,
+			message: msg,
+			range: node.getRange?.() || {
+				start: {
+					character: 1,
+					line: 1
+				},
+				end: {
+					character: 1,
+					line: 1
+				}
+			}
+		})).concat(this.messages);
+	}
+	constructor(nodes, messages = [], badNodes = new Map(), issues = {}, parent, i = -1) {
+		_define_property$6(this, "nodes", void 0);
+		_define_property$6(this, "messages", void 0);
+		_define_property$6(this, "badNodes", void 0);
+		_define_property$6(this, "issues", void 0);
+		_define_property$6(this, "parent", void 0);
+		_define_property$6(this, "i", void 0);
+		_define_property$6(this, "$", void 0);
+		this.nodes = nodes;
+		this.messages = messages;
+		this.badNodes = badNodes;
+		this.issues = issues;
+		this.parent = parent;
+		this.i = i;
+	}
+};
+
+//#endregion
+//#region packages/core/src/parser/utils.ts
+function toVsCodeRange(start, end, startOffset = 0, endOffset = 0) {
+	return {
+		start: {
+			line: start.row - 1,
+			character: start.col + startOffset
+		},
+		end: {
+			line: end.row - 1,
+			character: end.col + endOffset
+		}
+	};
+}
+function resolveAtscriptFromPath(from, id) {
+	return `file://${path$1.join(id.slice(7).split("/").slice(0, -1).join("/"), from)}.as`;
+}
+function getRelPath(fromUri, toUri) {
+	const fromPath = new URL(fromUri).pathname;
+	const toPath = new URL(toUri).pathname;
+	const relPath = path$1.relative(path$1.dirname(fromPath), toPath);
+	const { dir, name } = path$1.parse(relPath);
+	const prefix = dir.startsWith("..") ? "" : "./";
+	return `${prefix}${dir ? `${dir}/` : ""}${name}`;
+}
+
+//#endregion
+//#region packages/core/src/tokenizer/tokens/a-identifier.token.ts
+const AIdentifierToken = new BasicNode({
+	icon: "@",
+	tokens: [RegExp("@[\\p{ID_Continue}$.]*", "u"), RegExp("[^\\p{ID_Continue}$.]", "u")],
+	tokenOE: "-eject"
+}).mapContent("text", "join-clear").onMatch((context) => {
+	context.customData.type = "annotation";
+});
+
+//#endregion
+//#region packages/core/src/tokenizer/tokens/block.token.ts
+const pairs = {
+	"{": "}",
+	"(": ")",
+	"[": "]"
+};
+const BlockToken = new BasicNode({
+	label: "block",
+	icon: "→",
+	tokens: [RegExp("(?<text>[([{])", "u"), (context) => pairs[context.getCustomData().text] || ""],
+	tokenOE: "omit-omit",
+	skipToken: /\s/u
+}).onMatch((context) => {
+	context.customData.type = "block";
+});
+
+//#endregion
+//#region packages/core/src/tokenizer/tokens/comment.token.ts
+const inline = new BasicNode({
+	label: "inline-comment",
+	icon: "“",
+	tokens: ["//", /$/mu],
+	tokenOE: "omit-omit"
+}).mapContent("text", "join-clear").popsAtEOFSource(true).onMatch((context) => {
+	context.customData.type = "comment";
+});
+const block$1 = new BasicNode({
+	label: "block-comment",
+	icon: "“",
+	tokens: ["/*", "*/"],
+	tokenOE: "omit-omit"
+}).mapContent("text", "join-clear").popsAtEOFSource(true).onMatch((context) => {
+	context.customData.type = "comment";
+});
+const commentNodes = {
+	inline,
+	block: block$1,
+	all: [inline, block$1]
+};
+
+//#endregion
+//#region packages/core/src/tokenizer/tokens/identifier.token.ts
+const IdentifierToken = new BasicNode({
+	icon: "I",
+	tokens: [RegExp("[\\p{ID_Start}$_][\\p{ID_Continue}$]*", "u"), RegExp("[^\\p{ID_Continue}$]", "u")],
+	tokenOE: "consume-eject"
+}).mapContent("text", "join-clear").onMatch((context) => {
+	context.customData.type = "identifier";
+});
+
+//#endregion
+//#region packages/core/src/tokenizer/tokens/number.token.ts
+const NumberToken = new BasicNode({
+	icon: "N",
+	tokens: [RegExp("\\d[\\p{ID_Continue}$]*", "u"), RegExp("[^\\p{ID_Continue}$]", "u")],
+	tokenOE: "consume-eject"
+}).mapContent("text", "join-clear").onMatch((context) => {
+	context.customData.type = "number";
+});
+
+//#endregion
+//#region packages/core/src/tokenizer/tokens/punctuation.token.ts
+const PunctuationToken = new BasicNode({
+	tokens: [RegExp("(?<text>[\\n!&+,\\-./:;=?|])", "u"), ""],
+	tokenOE: "omit-omit",
+	icon: "..."
+}).onMatch((context) => {
+	context.customData.type = "punctuation";
+});
+
+//#endregion
+//#region packages/core/src/tokenizer/tokens/text.node.ts
+const TextToken = new BasicNode({
+	icon: "T",
+	tokens: [RegExp("(?<quote>[\"'])", "u"), (context) => new RegExp(`(?<end>${context.getCustomData().quote || ""}|\\n)`)],
+	backSlash: "-ignore",
+	tokenOE: "omit-omit"
+}).mapContent("text", "join-clear").onMatch((context) => {
+	context.customData.type = "text";
+}).onPop((context) => {
+	context.customData.multiline = context.customData.end === "\n";
+});
+
+//#endregion
+//#region packages/core/src/tokenizer/tokens/index.ts
+const tokens = {
+	aIdentifier: AIdentifierToken,
+	punctuation: PunctuationToken,
+	comments: commentNodes.all,
+	inlineComment: commentNodes.inline,
+	blockComment: commentNodes.block,
+	block: BlockToken,
+	identifier: IdentifierToken,
+	number: NumberToken,
+	text: TextToken,
+	root: undefined
+};
+const root = new BasicNode({
+	label: "root",
+	skipToken: /\s/u
+}).addRecognizes(...tokens.comments, tokens.block, tokens.aIdentifier, tokens.identifier, tokens.text, tokens.number, tokens.punctuation);
+tokens.root = root;
+BlockToken.addRecognizes(...tokens.comments, tokens.block, tokens.aIdentifier, tokens.identifier, tokens.text, tokens.number, tokens.punctuation);
+const mapContent = (content) => content.map((item) => {
+	if (typeof item === "string") return {
+		type: "unknown",
+		text: item
+	};
+	const data = item.getCustomData();
+	data.getRange = () => toVsCodeRange(item.startPos, item.endPos, data.startOffset, data.endOffset);
+	return data;
+});
+for (const node of Object.values(tokens)) if (node instanceof BasicNode) node.popsAtEOFSource(true).mapContent("children", mapContent);
+
+//#endregion
+//#region packages/core/src/tokenizer/index.ts
+function tokenize(source, debug = false) {
+	const tokens$1 = root.parse(source);
+	if (debug) console.log(tokens$1.toTree());
+	return mapContent(tokens$1.content);
+}
+
+//#endregion
+//#region packages/core/src/parser/pipes/tokens.pipe.ts
+const identifier = (...text$2) => $token("identifier", text$2.length > 0 ? text$2 : undefined);
+const text = (...text$2) => $token("text", text$2.length > 0 ? text$2 : undefined);
+const block = (...text$2) => $token("block", text$2.length > 0 ? text$2.map((v) => v[0]) : undefined);
+const pun = (...text$2) => $token("punctuation", text$2.length > 0 ? text$2 : undefined);
+function $token(name, text$2) {
+	const opts = {
+		optional: false,
+		saveAs: undefined,
+		skip: undefined,
+		expect: [{
+			node: name,
+			text: text$2
+		}],
+		isGlobal: false,
+		empty: false,
+		wrapper: undefined,
+		wrapMultiple: false,
+		debug: false,
+		eob: false,
+		suppressEobError: false,
+		lookBehind: false
+	};
+	return {
+		expect: [{
+			node: name,
+			text: text$2
+		}],
+		handler(ni, target) {
+			if (opts.debug) debugger;
+			let firstRun = true;
+			while (firstRun || opts.wrapMultiple) {
+				firstRun = false;
+				if (!ni.$) {
+					const ok = opts.eob || opts.optional;
+					if (!ok && !opts.suppressEobError) ni.unexpectedEOB();
+					return ok;
+				}
+				let matched = ni.satisfies(...opts.expect);
+				if (!matched && opts.lookBehind) {
+					matched = ni.fork().move(-1).satisfies(...opts.expect);
+					if (matched) ni.move(-1);
+				}
+				if (matched) {
+					if (opts.empty && ni.$.children?.length) {
+						ni.unexpected(false, `Expected empty block`);
+						return opts.optional;
+					}
+					if (opts.saveAs) target.node.saveToken(new Token(ni.$), opts.saveAs);
+					ni.accepted();
+					if (opts.wrapper) {
+						const wrapped = target.node;
+						target.node = opts.wrapper().wrap(wrapped, new Token(ni.$));
+					}
+					ni.move();
+					if (opts.skip) ni.skip(opts.skip);
+					if (opts.wrapMultiple) continue;
+else return true;
+				} else {
+					if (!opts.optional) ni.unexpected();
+					return opts.optional;
+				}
+			}
+			return true;
+		},
+		saveAs(v) {
+			opts.saveAs = v;
+			return this;
+		},
+		wrap(sn, multiple = false) {
+			opts.wrapper = sn;
+			opts.wrapMultiple = multiple;
+			return this;
+		},
+		optional() {
+			opts.optional = true;
+			return this;
+		},
+		empty() {
+			opts.empty = true;
+			return this;
+		},
+		skip(...p) {
+			opts.skip = p;
+			return this;
+		},
+		or(t) {
+			opts.expect.push(...t.expect);
+			return this;
+		},
+		orEob() {
+			opts.eob = true;
+			return this;
+		},
+		suppressEobError() {
+			opts.suppressEobError = true;
+			return this;
+		},
+		global() {
+			opts.isGlobal = true;
+			return this;
+		},
+		lookBehind() {
+			opts.lookBehind = true;
+			return this;
+		},
+		debug() {
+			opts.debug = true;
+			return this;
+		}
+	};
+}
+
+//#endregion
+//#region packages/core/src/parser/pipes/core.pipe.ts
+function $pipe(entity, pipe = []) {
+	pipe.forEach((p, i) => Object.assign(p, { toString: () => `${entity}.${i}` }));
+	return {
+		targetFactory: () => {
+			switch (entity) {
+				case "interface": return new $n.SemanticInterfaceNode();
+				case "array": return new $n.SemanticArrayNode();
+				case "const": return new $n.SemanticConstNode();
+				case "group": return new $n.SemanticGroup();
+				case "prop": return new $n.SemanticPropNode();
+				case "type": return new $n.SemanticTypeNode();
+				case "ref": return new $n.SemanticRefNode();
+				case "structure": return new $n.SemanticStructureNode();
+				case "tuple": return new $n.SemanticTupleNode();
+				case "import": return new $n.SemanticImportNode();
+				case "primitive": throw new Error("Can't create pipe for primitive node");
+				default: throw new Error(`Can't create pipe for ${entity} node`);
+			}
+		},
+		pipe,
+		toString: () => entity,
+		skipTokens: [],
+		stopCondition: undefined,
+		skip(...s) {
+			this.skipTokens.push(...s);
+			return this;
+		},
+		stop(sc) {
+			this.stopCondition = sc;
+			return this;
+		},
+		t(node, skip = []) {
+			this.pipe.push($token(node).saveAs("identifier").skip(...skip));
+			return this;
+		}
+	};
+}
+function runPipes(pipes$1, ni, singlePass = false) {
+	const nodes = [];
+	while (ni.$) {
+		let matched = true;
+		let depth = ni.index;
+		for (const { targetFactory, pipe, skipTokens: skip, stopCondition } of pipes$1) {
+			const target = { node: targetFactory() };
+			const fork = ni.fork();
+			fork.skip(skip);
+			if (!fork.$) {
+				ni.unfork(fork);
+				break;
+			}
+			matched = true;
+			for (const { handler } of pipe) if (!handler(fork, target)) {
+				matched = false;
+				break;
+			}
+			if (fork.index > depth) depth = fork.index;
+			if (matched) {
+				nodes.push(target.node);
+				ni.unfork(fork);
+				if (stopCondition && stopCondition(fork)) return nodes;
+				ni.move(-1);
+				break;
+			}
+		}
+		if (singlePass) return nodes;
+		if (!matched) {
+			ni.shouldHaveError(depth);
+			ni.move(depth - ni.index);
+		}
+		ni.move();
+		if (matched) {} else {
+			ni.confirmIssues();
+			ni.skipUntil([";", "\n"]);
+		}
+	}
+	return nodes;
+}
+function runPipesOnce(pipes$1, ni) {
+	return runPipes(pipes$1, ni, true)[0];
+}
+
+//#endregion
+//#region packages/core/src/parser/grouping.ts
+function groupByPriority(nodes, priority) {
+	if (nodes.length === 1) return nodes[0];
+	if (nodes.length === 0) return undefined;
+	if (nodes.length % 2 === 0) throw new Error(`Invalid number of nodes ${nodes.length}. Odd number expected`);
+	let currentPass = nodes;
+	let temporaryResult = [];
+	let groupped = [];
+	for (const p of priority) {
+		for (const [i, node] of currentPass.entries()) {
+			const isOperator = i % 2 === 1;
+			if (!isOperator && node instanceof Token) throw new Error(`Unexpected token ${node.toString()} at ${i}`);
+else if (isOperator && !(node instanceof Token)) throw new Error(`Unexpected token ${isGroup(node) ? node.op : node.token.toString()} at ${i}`);
+			if (isOperator) {
+				if (node.text !== p) temporaryResult.push(node);
+				continue;
+			}
+			const prev = currentPass[i - 1]?.text;
+			const next = currentPass[i + 1]?.text;
+			if (prev !== p && next !== p) {
+				temporaryResult.push(node);
+				continue;
+			}
+			if (prev === p || next === p) {
+				groupped.push(node);
+				if (next !== p) {
+					temporaryResult.push(new $n.SemanticGroup(groupped, p));
+					groupped = [];
+				}
+			}
+		}
+		currentPass = temporaryResult;
+		temporaryResult = [];
+	}
+	const output = currentPass[0];
+	return output.length === 1 ? output.first : output;
+}
+
+//#endregion
+//#region packages/core/src/parser/pipes/special.pipe.ts
+function refWithChain() {
+	const s = {
+		id: { node: "identifier" },
+		dot: {
+			node: "punctuation",
+			text: "."
+		},
+		block: {
+			node: "block",
+			text: "["
+		},
+		end: {
+			node: "punctuation",
+			text: ";"
+		}
+	};
+	return { handler(ni, target) {
+		ni.skip(["\n"]);
+		if (!ni.$) return false;
+		if (ni.satisfies(s.id)) {
+			ni.accepted();
+			target.node.saveToken(new Token(ni.$), "identifier");
+		} else return false;
+		ni.move();
+		if (ni.fork().skip(["\n"]).satisfies(s.end)) {
+			ni.skip(["\n", ";"]);
+			return true;
+		}
+		const fork = ni.fork();
+		let isDot = fork.skip(["\n"]).satisfies(s.dot);
+		let isBlock = fork.satisfies(s.block);
+		while (fork.$ && (isDot || isBlock)) {
+			if (isBlock) if (fork.$.children?.length === 0) {
+				while (isBlock && fork.$.children?.length === 0) {
+					target.node = new SemanticArrayNode().wrap(target.node, new Token(fork.$));
+					fork.move();
+					fork.skip(["\n", ";"]);
+					isBlock = fork.satisfies(s.block);
+				}
+				ni.unfork(fork);
+				return true;
+			} else if (fork.$.children?.length === 1 && fork.$.children[0].type === "text") {
+				if (isRef(target.node)) target.node.addChain(new Token(fork.$.children[0]));
+			} else return true;
+else {
+				fork.skip(["\n"]);
+				if (fork.next().satisfies(s.id)) {
+					if (isRef(target.node)) target.node.addDot(new Token(fork.$));
+					fork.move();
+					if (isRef(target.node) && fork.$) target.node.addChain(new Token(fork.$));
+				} else {
+					if (isRef(target.node)) target.node.addDot(new Token(fork.$));
+					fork.unexpected();
+					fork.move(1);
+					fork.unexpected();
+					ni.unfork(fork);
+					ni.move();
+					ni.skip([";", "\n"]);
+					return true;
+				}
+			}
+			fork.move();
+			ni.unfork(fork);
+			if (ni.fork().skip(["\n"]).satisfies(s.end)) {
+				ni.skip(["\n", ";"]);
+				return true;
+			}
+			isDot = fork.skip(["\n"]).satisfies(s.dot);
+			isBlock = fork.satisfies(s.block);
+		}
+		return true;
+	} };
+}
+function annotations() {
+	const opts = {
+		annotation: { node: "annotation" },
+		argument: [{ node: ["number", "text"] }, {
+			node: "identifier",
+			text: [
+				"true",
+				"false",
+				"undefined",
+				"null"
+			]
+		}],
+		comma: {
+			node: "punctuation",
+			text: ","
+		},
+		end: {
+			node: "punctuation",
+			text: [";", "\n"]
+		}
+	};
+	return { handler(ni, target) {
+		while (ni.$ && ni.satisfies(opts.annotation)) {
+			const key = ni.$.text?.slice(1);
+			ni.accepted();
+			const addArgument = target.node.annotate(key, new Token(ni.$));
+			ni.move();
+			while (ni.satisfies(opts.comma)) {
+				addArgument(new Token(ni.$));
+				ni.accepted();
+				ni.move();
+			}
+			while (ni.satisfies(...opts.argument)) {
+				addArgument(new Token(ni.$));
+				ni.accepted();
+				ni.move();
+				if (ni.satisfies(opts.comma)) {
+					ni.accepted();
+					ni.move();
+					while (ni.satisfies(opts.comma)) {
+						addArgument(new Token(ni.$));
+						ni.accepted();
+						ni.move();
+					}
+				} else break;
+			}
+			if (ni.satisfies(opts.end)) ni.skip([";", "\n"]);
+else if (ni.$) {
+				ni.unexpected(false, `Unexpected token in annotation ${ni.toString()}`);
+				ni.skipUntil([";", "\n"]);
+				ni.skip([";", "\n"]);
+			}
+		}
+		return true;
+	} };
+}
+function definition(pipes$1) {
+	const opts = {
+		sep: [],
+		priority: false,
+		multiple: false,
+		from: undefined,
+		debug: false,
+		skip: []
+	};
+	return {
+		handler(ni, target) {
+			const targetNode = target.node;
+			if (opts.debug) debugger;
+			if (!ni.$ && !opts.from) return false;
+			if (opts.from && !targetNode.has(opts.from)) {
+				ni.unexpected(false, `Unexpected definition`);
+				return false;
+			}
+			const fork = opts.from ? ni.fork(targetNode.token(opts.from)?.children) : ni;
+			if (opts.from && !fork.nodesLeft()) {
+				targetNode.define(new $n.SemanticGroup());
+				return true;
+			}
+			const resolvedPipes = pipes$1.map((p) => typeof p === "function" ? p() : p);
+			const node = runPipesOnce(resolvedPipes, fork);
+			if (node) {
+				fork.accepted();
+				fork.move();
+				fork.skip(opts.skip);
+				if (!opts.multiple) {
+					targetNode.define(node);
+					return true;
+				}
+			} else {
+				fork.unexpected();
+				return false;
+			}
+			const nodes = [node];
+			while (opts.multiple && fork.$) {
+				if (opts.sep.length > 0) if (fork.satisfies({
+					node: "punctuation",
+					text: opts.sep
+				})) {
+					if (opts.priority) if (fork.next(opts.skip).$) nodes.push(new Token(fork.$));
+else {
+						fork.unexpected(false, "Unexpected end of group");
+						break;
+					}
+					fork.accepted();
+					fork.move();
+					fork.skip(opts.skip);
+				} else {
+					if (fork.$) fork.unexpected();
+					break;
+				}
+				const nextNode = runPipesOnce(resolvedPipes, fork);
+				if (nextNode) {
+					nodes.push(nextNode);
+					fork.accepted();
+					fork.move();
+					fork.skip(opts.skip);
+				} else {
+					fork.unexpected();
+					return false;
+				}
+			}
+			if (nodes.length === 1) targetNode.define(nodes[0]);
+else if (opts.priority && opts.sep.length > 0) {
+				if (nodes.length % 2 === 0) {
+					fork.next().unexpected(false, "Error in group definition");
+					return false;
+				}
+				targetNode.define(groupByPriority(nodes, opts.sep));
+			} else targetNode.define(new $n.SemanticGroup(nodes));
+			return true;
+		},
+		separatedBy(...p) {
+			opts.multiple = true;
+			opts.sep.push(...p);
+			return this;
+		},
+		respectPriority() {
+			opts.priority = true;
+			return this;
+		},
+		multiple() {
+			opts.multiple = true;
+			return this;
+		},
+		from(attr) {
+			opts.from = attr;
+			return this;
+		},
+		skip(...skip) {
+			opts.skip = skip;
+			return this;
+		},
+		debug() {
+			opts.debug = true;
+			return this;
+		}
+	};
+}
+function unwrap(attr) {
+	const opts = { pipes: [] };
+	return {
+		handler(ni, target) {
+			if (!target.node.has(attr)) return false;
+			const token = target.node.token(attr);
+			const fork = ni.fork(token.children || []);
+			const nodes = runPipes(opts.pipes, fork);
+			target.node.define(new $n.SemanticGroup(nodes));
+			return true;
+		},
+		with(pipes$1) {
+			opts.pipes = pipes$1;
+			return this;
+		}
+	};
+}
+
+//#endregion
+//#region packages/core/src/parser/pipes/pipes.ts
+const ref = $pipe("ref", [refWithChain()]);
+const constText = defineValuePipe("const", "text", false);
+const constNumber = defineValuePipe("const", "number", false);
+const allowedValuesPipeArray = [
+	ref,
+	constText,
+	constNumber
+];
+const tuplePipeArray = [
+	block("[]").saveAs("identifier"),
+	definition(allowedValuesPipeArray).from("identifier").separatedBy("&", "|", ",").skip("\n").respectPriority(),
+	block("[]").optional().empty().wrap(() => new SemanticArrayNode(), true)
+];
+const groupPipeArray = [
+	block("()").saveAs("identifier"),
+	definition(allowedValuesPipeArray).from("identifier").separatedBy("&", "|").skip("\n").respectPriority(),
+	block("[]").optional().empty().wrap(() => new $n.SemanticArrayNode(), true)
+];
+const tuple = $pipe("tuple", tuplePipeArray).skip("\n");
+const group = $pipe("group", groupPipeArray).skip("\n");
+allowedValuesPipeArray.unshift(tuple);
+allowedValuesPipeArray.unshift(group);
+const type = $pipe("type", [
+	annotations(),
+	identifier("export").saveAs("export").optional().skip("\n"),
+	identifier("type").saveAs("type").skip("\n").suppressEobError(),
+	identifier().saveAs("identifier").global().skip("\n"),
+	pun("=").skip("\n"),
+	definition(allowedValuesPipeArray).separatedBy("&", "|").skip("\n").respectPriority()
+]).skip("\n", ";");
+const props = $pipe("prop", [
+	annotations(),
+	identifier().or(text()).saveAs("identifier").skip("\n"),
+	pun("?").saveAs("optional").optional().skip("\n"),
+	pun(":").skip("\n"),
+	definition(allowedValuesPipeArray).separatedBy("&", "|").skip("\n").respectPriority(),
+	pun(";", ",", "\n").orEob().lookBehind()
+]).skip("\n", ";", ",");
+const structurePipeArray = [
+	block("{}").saveAs("identifier"),
+	unwrap("identifier").with([props]),
+	block("[]").optional().empty().wrap(() => new $n.SemanticArrayNode(), true)
+];
+function structureBlock(array = false) {
+	return $pipe("structure", array ? structurePipeArray : structurePipeArray.slice(0, 2)).skip("\n", ";");
+}
+allowedValuesPipeArray.unshift(structureBlock(true));
+const interfaceType = $pipe("interface", [
+	annotations(),
+	identifier("export").saveAs("export").optional().skip("\n"),
+	identifier("interface").saveAs("type").skip("\n").suppressEobError(),
+	identifier().saveAs("identifier").global().skip("\n"),
+	definition([structureBlock()])
+]).skip("\n", ";");
+function defineValuePipe(entity, name, supportArray = false) {
+	const steps = [$token(name).saveAs("identifier")];
+	if (supportArray) steps.push(block("[]").optional().empty().wrap(() => new $n.SemanticArrayNode(), true));
+	return $pipe(entity, steps).skip("\n");
+}
+const importPipe = $pipe("import", [
+	identifier("import").saveAs("identifier").skip("\n"),
+	block("{}").saveAs("inner").skip("\n"),
+	identifier("from").saveAs("from").skip("\n"),
+	text().saveAs("path").skip(";", "\n"),
+	definition([$pipe("ref", [identifier().saveAs("identifier").skip("\n")])]).from("inner").separatedBy(",").skip("\n").respectPriority()
+]).skip("\n", ";");
+const pipes = {
+	type,
+	props,
+	interfaceType,
+	importPipe,
+	tuple
+};
+
+//#endregion
+//#region packages/core/src/token-index/blocks-index.ts
+function _define_property$5(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+/**
+* Compares two positions.
+* @param a - The first position.
+* @param b - The second position.
+* @returns -1 if `a` is less than `b`, 1 if `a` is greater than `b`, 0 if they are equal.
+*/ function comparePos(a, b) {
+	if (a.line < b.line) return -1;
+	if (a.line > b.line) return 1;
+	if (a.character < b.character) return -1;
+	if (a.character > b.character) return 1;
+	return 0;
+}
+/**
+* Checks if a given position (line, character) is contained within a token's range.
+* @param token - The token to check.
+* @param line - The line number of the position.
+* @param character - The character number of the position.
+* @returns `true` if the position is within the token's range, `false` otherwise.
+*/ function contains(token, line, character) {
+	const startCmp = comparePos(token.range.start, {
+		line,
+		character
+	});
+	const endCmp = comparePos(token.range.end, {
+		line,
+		character
+	});
+	return startCmp <= 0 && endCmp > 0;
+}
+/**
+* Determines if token `a` is more nested than token `b`.
+* @param a - The first token.
+* @param b - The second token.
+* @returns `true` if `a` is more nested than `b`, `false` otherwise.
+*/ function moreNested(a, b) {
+	const startCmp = comparePos(a.range.start, b.range.start);
+	const endCmp = comparePos(a.range.end, b.range.end);
+	return startCmp >= 0 && endCmp <= 0;
+}
+var BlocksIndex = class {
+	/**
+	* Adds a new token to the index. The token collection is maintained in sorted order by start position.
+	* @param block - The token to add.
+	*/ add(block$2) {
+		let left = 0;
+		let right = this.blocks.length;
+		while (left < right) {
+			const mid = left + right >> 1;
+			if (comparePos(this.blocks[mid].range.start, block$2.range.start) < 0) left = mid + 1;
+else right = mid;
+		}
+		this.blocks.splice(left, 0, block$2);
+	}
+	/**
+	* Finds the most nested token at a specific position.
+	* @param line - The line number of the position.
+	* @param character - The character number of the position.
+	* @returns The most nested token at the given position, or `undefined` if no token is found.
+	*/ at(line, character) {
+		const candidates = [];
+		for (const block$2 of this.blocks) {
+			if (comparePos(block$2.range.start, {
+				line,
+				character
+			}) > 0) break;
+			if (contains(block$2, line, character)) candidates.push(block$2);
+		}
+		if (candidates.length === 0) return undefined;
+		let result = candidates[0];
+		for (let i = 1; i < candidates.length; i++) if (moreNested(candidates[i], result)) result = candidates[i];
+		return result;
+	}
+	before(line, character) {
+		throw new Error("Not implemented");
+	}
+	constructor() {
+		_define_property$5(this, "blocks", []);
+	}
+};
+
+//#endregion
+//#region packages/core/src/token-index/tokens-index.ts
+function _define_property$4(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 TokensIndex = class {
+	/**
+	* Adds a token to the index. The token is stored based on its starting line.
+	* @param token - The token to add to the index.
+	*/ add(token) {
+		if (!token?.range) return;
+		const line = token.range.start.line;
+		this.tokensMap[line] = this.tokensMap[line] ?? new Set();
+		this.tokensMap[line].add(token);
+	}
+	/**
+	* Retrieves a token at a specific line and character, if one exists.
+	* @param line - The line number to search in.
+	* @param character - The character position within the line to search for.
+	* @returns The token at the specified line and character, or `undefined` if none exists.
+	*/ at(line, character) {
+		const tokens$1 = this.tokensMap[line];
+		if (!tokens$1) return undefined;
+		return Array.from(tokens$1).find((t) => t.range.start.character <= character && t.range.end.character >= character);
+	}
+	/**
+	* Retrieves either the token at the specified (line, character), or if none exists,
+	* the closest token that ends on or before that position. This method checks:
+	*   1. If a token spans (line, character), return it immediately.
+	*   2. Otherwise, look within the same line for tokens that end before `character`.
+	*   3. If still none found, move upwards to previous lines and return the token that ends last.
+	* @param line - The line number to search in.
+	* @param character - The character position within the line to search for.
+	* @returns The found token, or `undefined` if no suitable token is found.
+	*/ before(line, character) {
+		const current = this.at(line, character);
+		if (current) return current;
+		const tokensAtLine = this.tokensMap[line];
+		if (tokensAtLine) {
+			let candidate;
+			for (const t of tokensAtLine) if (t.range.end.character < character && (!candidate || t.range.end.character > candidate.range.end.character)) candidate = t;
+			if (candidate) return candidate;
+		}
+		for (let l = line - 1; l >= 0; l--) {
+			const tokens$1 = this.tokensMap[l];
+			if (tokens$1 && tokens$1.size > 0) {
+				let candidate;
+				for (const t of tokens$1) if (!candidate || t.range.end.character > candidate.range.end.character) candidate = t;
+				if (candidate) return candidate;
+			}
+		}
+		return undefined;
+	}
+	constructor() {
+		/**
+		* An array where each index corresponds to a line number, storing a set of tokens
+		* associated with that line.
+		*/ _define_property$4(this, "tokensMap", []);
+	}
+};
+
+//#endregion
+//#region packages/core/src/document.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 AtscriptDoc = class {
+	get name() {
+		return this.id.split("/").pop();
+	}
+	get primitives() {
+		return Array.from(this.config.primitives?.values() ?? []);
+	}
+	async render(format) {
+		return this.manager?.render(this, format);
+	}
+	resolveAnnotation(name) {
+		return resolveAnnotation(name, this.config.annotations);
+	}
+	updateDependencies(docs) {
+		const newDependencies = new Set(docs);
+		this.dependencies.forEach((d) => {
+			if (!newDependencies.has(d)) {
+				d.dependants.delete(this);
+				this.dependencies.delete(d);
+				this.dependenciesMap.delete(d.id);
+			}
+		});
+		newDependencies.forEach((d) => {
+			d.dependants.add(this);
+			this.dependencies.add(d);
+			this.dependenciesMap.set(d.id, d);
+		});
+	}
+	get text() {
+		return this._text;
+	}
+	update(text$2, debug = false) {
+		this._text = text$2;
+		this.cleanup();
+		const rawTokens = tokenize(text$2, debug);
+		const ni = new NodeIterator(rawTokens, []).move();
+		this.nodes = runPipes([
+			pipes.importPipe,
+			pipes.type,
+			pipes.interfaceType
+		], ni);
+		if (debug) console.log(this.nodes.map((n) => n.toString()).join("\n"));
+		this.semanticMessages = ni.getErrors();
+		this.registerNodes(this.nodes);
+	}
+	cleanup() {
+		this.exports.clear();
+		this.registry.clear();
+		this.importedDefs.clear();
+		this.messages = [];
+		this.referred = [];
+		this.imports.clear();
+		this._allMessages = undefined;
+		this.tokensIndex = new TokensIndex();
+		this.blocksIndex = new BlocksIndex();
+		this.resolvedAnnotations = [];
+		this.annotations = [];
+	}
+	registerNodes(nodes) {
+		for (const node of nodes) {
+			node.registerAtDocument(this);
+			node.referredIdentifiers.forEach((t) => {
+				t.isReference = true;
+				this.referred.push(t);
+				this.tokensIndex.add(t);
+			});
+		}
+	}
+	registerAnnotation(annotationTokens) {
+		this.annotations.push(annotationTokens);
+		const mainToken = annotationTokens.token;
+		const args = annotationTokens.args;
+		this.tokensIndex.add(mainToken);
+		args?.forEach((a) => this.tokensIndex.add(a));
+		const annotationSpec = this.resolveAnnotation(mainToken.text.slice(1));
+		if (annotationSpec) {
+			this.registerMessages(annotationSpec.validate(mainToken, args || [], this));
+			annotationSpec.modify(mainToken, args || [], this);
+			this.resolvedAnnotations.push(mainToken);
+		} else {
+			let severity = 0;
+			switch (this.config.unknownAnnotation) {
+				case "warn":
+					severity = 2;
+					break;
+				case "error":
+					severity = 1;
+					break;
+				default:
+			}
+			if (severity > 0) this.registerMessage(mainToken, `Unknown annotation "${mainToken.text}"`, severity, "dim");
+		}
+	}
+	/**
+	* Recursively resolves a type reference (and any property chain) to find the final underlying definition.
+	*
+	* This method performs a **multi-step** resolution:
+	*  1. Locates the declaration owner of the type (via `getDeclarationOwnerNode`).
+	*  2. Follows references, type aliases, or nested property chains:
+	*     - For “Ref” nodes, it uses the identifier to look up the next type.
+	*     - For “Type” nodes, it calls `getDefinition()` to move to the underlying structure.
+	*     - For property chains (`chain`), it navigates nested properties or nested types,
+	*       resolving each level until the final type is reached.
+	*
+	* @param {string} name - The name of the type or identifier to resolve.
+	* @param {Array<string | Token>} [chain=[]] - An optional chain of properties or tokens, each of which
+	*  refines the path to the final type (e.g., for `SomeType.prop1.prop2`, `chain` might be `[ "prop1", "prop2" ]`).
+	* @returns {Object | undefined} An object containing:
+	*   - `doc`: The `AtscriptDoc` where the final definition is located.
+	*   - `node`: The last encountered `SemanticNode` before reaching the final underlying definition (often a `Prop` node).
+	*   - `def`: The final resolved `SemanticNode`.
+	*
+	* If the type cannot be resolved or does not exist, returns `undefined`.
+	*/ unwindType(name, chain = [], watchCb, _tracked) {
+		const tracked = _tracked || new Set();
+		const decl = this.getDeclarationOwnerNode(name);
+		if (!decl) return undefined;
+		const callCb = watchCb ? () => {
+			if (def && !tracked.has(def) && [
+				"type",
+				"primitive",
+				"prop",
+				"interface"
+			].includes(def.entity)) {
+				tracked.add(def);
+				watchCb(def);
+			}
+		} : () => {};
+		let node;
+		let def = decl.node;
+		let doc = decl.doc;
+		const resolveRef = () => {
+			if (isRef(def)) {
+				const d = doc.unwindType(def.token("identifier").text, def.chain, watchCb, tracked);
+				doc = d?.doc || doc;
+				def = d?.def;
+			}
+		};
+		const resolveType = () => {
+			while (isType(def)) {
+				callCb();
+				def = def.getDefinition();
+				node = def;
+				resolveRef();
+			}
+		};
+		resolveType();
+		if (!def) return undefined;
+		for (const item of chain) {
+			const itemText = typeof item === "string" ? item : item.text;
+			if (!def) return undefined;
+			if (isProp(def)) if (def.nestedProps?.get(itemText)) def = def.nestedProps.get(itemText);
+else {
+				def = def.nestedType;
+				resolveRef();
+				resolveType();
+				if (isStructure(def) || isInterface(def)) def = def.props.get(itemText);
+			}
+else if (isStructure(def) || isInterface(def) || isPrimitive(def)) def = def.props.get(itemText);
+		}
+		if (_tracked) callCb();
+		while (isProp(def)) {
+			node = def;
+			def = def.getDefinition();
+			resolveRef();
+			resolveType();
+		}
+		return def ? {
+			def,
+			doc,
+			node
+		} : undefined;
+	}
+	getUsageListAt(line, character) {
+		const token = this.tokensIndex.at(line, character);
+		if (token) return this.usageListFor(token);
+	}
+	evalAnnotationsForNode(givenNode) {
+		let right = givenNode.annotations;
+		let def = givenNode.getDefinition();
+		if (def) {
+			if (isRef(def)) {
+				const unwound = this.unwindType(def.token("identifier").text, def.chain, (intermediate) => {
+					if (intermediate?.annotations) right = this.mergeNodesAnnotations(intermediate.annotations, right);
+				});
+				def = unwound?.def || def;
+			}
+			if (def) {
+				const merged = this.mergeIntersection(def);
+				right = this.mergeNodesAnnotations(merged.annotations, right);
+			}
+		}
+		return right;
+	}
+	usageListFor(token) {
+		if (token.isDefinition) {
+			const refs = this.referred.filter((t) => t.text === token.text).map((r) => ({
+				uri: this.id,
+				range: r.range,
+				token: r
+			}));
+			if (token.exported) for (const d of this.dependants) {
+				const imp = d.imports.get(this.id);
+				if (imp?.imports.find((t) => t.text === token.text)) refs.push(...d.referred.filter((t) => t.text === token.text).map((r) => ({
+					uri: d.id,
+					range: r.range,
+					token: r
+				})));
+			}
+			return refs;
+		}
+		if (isProp(token.parentNode)) {} else {
+			const defForToken = this.getDefinitionFor(token);
+			if (defForToken?.token?.isDefinition && defForToken.doc) return defForToken.doc.usageListFor(defForToken.token);
+		}
+		return undefined;
+	}
+	/**
+	* Retrieves the definition (i.e., the “go to definition” target) for a given token.
+	*
+	* This method provides a **single-step** resolution of the defining token:
+	*  - If the token is defined in the same document, returns that definition.
+	*  - If the token is imported, follows the import to return the defining token from the relevant document.
+	*  - If the token is a reference to a locally defined identifier, retrieves the local definition.
+	*
+	* @param {Token} token - The token for which to locate the definition.
+	* @returns {Object | undefined} An object containing:
+	*   - `uri`: The file path (URI) of the document where the definition is found.
+	*   - `doc`: The `AtscriptDoc` instance that owns the definition (if found).
+	*   - `token`: The defining token itself (if found).
+	*
+	* If no definition is found, returns `undefined`.
+	*/ getDefinitionFor(token) {
+		if (token.isDefinition && !token.imported) return {
+			uri: this.id,
+			doc: this,
+			token
+		};
+		if (token.fromPath) {
+			const absolutePath = resolveAtscriptFromPath(token.fromPath, this.id);
+			return {
+				uri: absolutePath,
+				doc: this.dependenciesMap.get(absolutePath),
+				token
+			};
+		}
+		if ((token.isReference || token.imported) && this.importedDefs.has(token.text) && this.dependenciesMap.size > 0) {
+			const from = this.importedDefs.get(token.text).text;
+			const absolutePath = resolveAtscriptFromPath(from, this.id);
+			const targetDoc = this.dependenciesMap.get(absolutePath);
+			if (targetDoc) {
+				const target = targetDoc.registry.definitions.get(token.text);
+				return target ? {
+					uri: targetDoc.id,
+					doc: targetDoc,
+					token: target
+				} : undefined;
+			}
+		}
+		if (token.isReference) {
+			const def = this.registry.definitions.get(token.text);
+			return def ? {
+				uri: this.id,
+				doc: this,
+				token: def
+			} : undefined;
+		}
+	}
+	getToDefinitionAt(line, character) {
+		const token = this.tokensIndex.at(line, character);
+		if (token) if (token.isChain && isRef(token.parentNode) && typeof token.index === "number") {
+			const id = token.parentNode.id;
+			const unwound = this.unwindType(id, token.parentNode.chain.slice(0, token.index));
+			if (unwound?.node) return [{
+				targetUri: unwound.doc.id,
+				targetRange: unwound.node.token("identifier")?.range ?? zeroRange,
+				targetSelectionRange: unwound.node.token("identifier")?.range ?? zeroRange,
+				originSelectionRange: token.range
+			}];
+		} else {
+			const result = this.getDefinitionFor(token);
+			return result ? [{
+				targetUri: result.uri,
+				targetRange: result.token?.range ?? zeroRange,
+				targetSelectionRange: result.token?.range ?? zeroRange,
+				originSelectionRange: token.range
+			}] : undefined;
+		}
+	}
+	registerImport({ from, imports, block: block$2 }) {
+		const importId = resolveAtscriptFromPath(from.text, this.id);
+		this.imports.set(importId, {
+			from,
+			imports
+		});
+		this.blocksIndex.add(block$2);
+		block$2.blockType = "import";
+		block$2.fromPath = from.text;
+		imports.forEach((t) => {
+			t.imported = true;
+			t.fromPath = from.text;
+			this.registerDefinition(t, true);
+			this.tokensIndex.add(t);
+			this.tokensIndex.add(from);
+			this.importedDefs.set(t.text, from);
+			from.fromPath = from.text;
+		});
+	}
+	registerDefinition(token, asImport = false) {
+		if (token) {
+			token.isDefinition = !asImport;
+			if (asImport) token.isReference = true;
+			this.tokensIndex.add(token);
+			this.registry.registerDefinition(token);
+		}
+	}
+	/**
+	* Finds the owning document and semantic node responsible for declaring a given identifier.
+	*
+	* This method checks:
+	* 1. Whether the identifier is a known primitive (from this document’s config).
+	* 2. If there's a local definition in this document's registry.
+	*    - If the definition is imported, it resolves the `fromPath`, locates the correct `AtscriptDoc`
+	*      in the dependency map, and recursively tries to get the declaration owner there.
+	*    - If the definition is local (not imported), it returns the current document (`this`) along with
+	*      the parent node that owns the definition and the token itself.
+	*
+	* @param {string} identifier - The name/identifier whose declaring node should be found.
+	* @returns {{ doc: AtscriptDoc; node?: SemanticNode; token?: Token } | undefined} An object containing:
+	*  - `doc`: The `AtscriptDoc` in which the identifier was ultimately declared.
+	*  - `node`: The parent `SemanticNode` that defines or owns the declaration (if applicable).
+	*  - `token`: The specific token for the declaration (if applicable).
+	*
+	* If no declaration is found, returns `undefined`.
+	*/ getDeclarationOwnerNode(identifier$1) {
+		if (this.config.primitives?.has(identifier$1)) return {
+			doc: this,
+			node: this.config.primitives.get(identifier$1)
+		};
+		const def = this.registry.definitions.get(identifier$1);
+		if (def?.imported && def.fromPath) {
+			const absolutePath = resolveAtscriptFromPath(def.fromPath, this.id);
+			const doc = this.dependenciesMap.get(absolutePath);
+			return doc?.getDeclarationOwnerNode(identifier$1);
+		} else if (!def?.imported) return def ? {
+			doc: this,
+			node: def.parentNode,
+			token: def
+		} : undefined;
+	}
+	registerExport(node) {
+		if (node.id) this.exports.set(node.id, node);
+	}
+	registerMessage(token, message, severity = 1, tag) {
+		if (this._allMessages) this._allMessages = undefined;
+		this.messages.push({
+			severity,
+			message,
+			range: token.range,
+			tags: tag === "dim" ? [1] : tag === "crossed" ? [2] : []
+		});
+	}
+	registerMessages(messages) {
+		if (messages) this.messages.push(...messages);
+	}
+	clearMessages() {
+		this._allMessages = undefined;
+	}
+	getUnusedTokens() {
+		const refSet = new Set(this.referred.filter((r) => !r.imported).map((r) => r.text));
+		const tokens$1 = [];
+		for (const [key, token] of Array.from(this.registry.definitions.entries())) if (!refSet.has(key) && !this.exports.has(key)) tokens$1.push(token);
+		return tokens$1;
+	}
+	getDiagMessages() {
+		if (!this._allMessages) {
+			this._allMessages = [
+				...this.registry.getErrors(),
+				...this.semanticMessages,
+				...this.messages
+			];
+			for (const t of this.referred) {
+				if (!this.registry.isDefined(t)) {
+					this._allMessages.push({
+						severity: 1,
+						message: `Unknown identifier "${t.text}"`,
+						range: t.range
+					});
+					continue;
+				}
+				if (isRef(t.parentNode)) {
+					const def = this.unwindType(t.parentNode.id, t.parentNode.chain)?.def;
+					if (isPrimitive(def) && !def.config.type) {
+						const token = t.parentNode.chain[t.parentNode.chain.length - 1] || t;
+						this._allMessages.push({
+							severity: 1,
+							message: "Invalid type",
+							range: token.range
+						});
+					}
+					if (t.parentNode.hasChain) {
+						const length = t.parentNode.chain.length - 1;
+						for (let i = length; i >= 0; i--) {
+							const token = t.parentNode.chain[i];
+							const decl = this.unwindType(t.parentNode.id, t.parentNode.chain.slice(0, i + 1));
+							if (!decl?.def) this._allMessages.push({
+								severity: 1,
+								message: `Unknown member "${token.text}"`,
+								range: token.range
+							});
+						}
+					}
+				}
+			}
+		}
+		return this._allMessages;
+	}
+	mergeIntersection(node) {
+		if (!isGroup(node)) return node;
+		if (node.op !== "&") return node;
+		const nodes = node.unwrap();
+		if (nodes.length === 0) return node;
+		if (nodes.length === 1) return nodes[0];
+		const newGroup = [];
+		let left = nodes[0];
+		for (let i = 1; i < nodes.length; i++) {
+			const right = nodes[i];
+			const merged = this.mergeDefs(left, right);
+			if (merged.length === 2) {
+				left = merged[1];
+				newGroup.push(merged[0]);
+			} else left = merged[0];
+		}
+		newGroup.push(left);
+		if (newGroup.length > 1) {
+			const newNode = new SemanticGroup(newGroup, "&");
+			return newNode;
+		} else return newGroup[0];
+	}
+	mergeDefs(_left, _right) {
+		let left = _left;
+		let right = _right;
+		if (isRef(left)) left = this.unwindType(left.id, left.chain)?.def;
+		if (isRef(right)) right = this.unwindType(right.id, right.chain)?.def;
+		if (!left || !right) return [_left, _right];
+		if (isPrimitive(left) && isPrimitive(right)) {
+			if (left.config.type === right.config.type) return [left];
+			const never$1 = new SemanticRefNode();
+			never$1.saveToken(new Token({
+				text: "never",
+				type: "identifier",
+				getRange: () => zeroRange
+			}), "identifier");
+			return [never$1];
+		}
+		if ((isStructure(left) || isInterface(left)) && (isStructure(right) || isInterface(right))) {
+			const mergedProps = [];
+			const allProps = new Set([...left.props.keys(), ...right.props.keys()]);
+			for (const key of allProps) {
+				const leftProp = left.props.get(key);
+				const rightProp = right.props.get(key);
+				let mergedDef;
+				if (leftProp && rightProp) {
+					const grp = new SemanticGroup([leftProp.getDefinition(), rightProp.getDefinition()], "&");
+					mergedDef = this.mergeIntersection(grp);
+				} else {
+					const oldProp = leftProp || rightProp;
+					mergedDef = this.mergeIntersection(oldProp.getDefinition());
+				}
+				const prop = new SemanticPropNode();
+				prop.saveToken((leftProp || rightProp).token("identifier"), "identifier");
+				if (isPrimitive(mergedDef)) {
+					const name = mergedDef.id;
+					mergedDef = new SemanticRefNode();
+					mergedDef.saveToken(new Token({
+						text: name,
+						type: "identifier",
+						getRange: () => zeroRange
+					}), "identifier");
+				}
+				prop.define(mergedDef);
+				prop.annotations = this.mergeNodesAnnotations(leftProp?.annotations, rightProp?.annotations);
+				const oldProps = [leftProp, rightProp].filter(Boolean);
+				let optionalToken = oldProps[0]?.token("optional");
+				for (const oldProp of oldProps) if (!oldProp.token("optional")) {
+					optionalToken = undefined;
+					break;
+				}
+				if (optionalToken) prop.saveToken(optionalToken, "optional");
+				mergedProps.push(prop);
+			}
+			const mergedStructure = new SemanticStructureNode();
+			mergedStructure.setProps(mergedProps);
+			this.resolveAnnotation;
+			mergedStructure.annotations = this.mergeNodesAnnotations(left.annotations, right.annotations);
+			return [mergedStructure];
+		}
+		const never = new SemanticRefNode();
+		never.saveToken(new Token({
+			text: "never",
+			type: "identifier",
+			getRange: () => zeroRange
+		}), "identifier");
+		return [never];
+	}
+	/**
+	* Merges two arrays of annotation tokens, ensuring that annotations from the
+	* `right` array take precedence over those from the `left` array.
+	*
+	* - Annotations from `right` are always included.
+	* - Annotations from `left` are included only if they are not already present in `right`.
+	* - This ensures that if an annotation exists in both arrays, the one from `right` is kept.
+	*
+	* @param left - An optional array of annotation tokens to merge (lower priority).
+	* @param right - An optional array of annotation tokens to merge (higher priority).
+	* @returns A merged array of annotation tokens, preserving order while preventing duplicates.
+	*/ mergeNodesAnnotations(left, right) {
+		const annotations$1 = [];
+		const savedAnnotations = new Set();
+		for (const a of right || []) {
+			annotations$1.push(a);
+			savedAnnotations.add(a.token.text);
+		}
+		for (const a of left || []) {
+			const spec = this.resolveAnnotation(a.token.text);
+			let append = spec && spec.config.multiple && spec.config.mergeStrategy === "append";
+			if (append || !savedAnnotations.has(a.token.text)) annotations$1.push(a);
+		}
+		return annotations$1;
+	}
+	constructor(id, config, manager) {
+		_define_property$3(this, "id", void 0);
+		_define_property$3(this, "config", void 0);
+		_define_property$3(this, "manager", void 0);
+		_define_property$3(this, "registry", void 0);
+		_define_property$3(this, "semanticMessages", void 0);
+		_define_property$3(this, "messages", void 0);
+		/**
+		* All the non-blocks tokens, that could be referred
+		*/ _define_property$3(this, "tokensIndex", void 0);
+		/**
+		* All the block-tokens
+		*/ _define_property$3(this, "blocksIndex", void 0);
+		/**
+		* Imports map by URI, contains from Token and imports[] tokens
+		*/ _define_property$3(this, "imports", void 0);
+		/**
+		* Map of imported definitions by type/interface identifier
+		*/ _define_property$3(this, "importedDefs", void 0);
+		/**
+		* Exported nodes by identifier
+		*/ _define_property$3(this, "exports", void 0);
+		/**
+		* Set of documents that this document depend on
+		*/ _define_property$3(this, "dependencies", void 0);
+		/**
+		* Set of documents that depend on this document
+		*/ _define_property$3(this, "dependants", void 0);
+		/**
+		* List of tokens that refer to some type or interface
+		*/ _define_property$3(this, "referred", void 0);
+		/**
+		* Map of dependencies (documents) by URI
+		*/ _define_property$3(this, "dependenciesMap", void 0);
+		_define_property$3(this, "nodes", void 0);
+		_define_property$3(this, "_text", void 0);
+		_define_property$3(this, "resolvedAnnotations", void 0);
+		_define_property$3(this, "annotations", void 0);
+		_define_property$3(this, "_allMessages", void 0);
+		this.id = id;
+		this.config = config;
+		this.manager = manager;
+		this.semanticMessages = [];
+		this.messages = [];
+		this.tokensIndex = new TokensIndex();
+		this.blocksIndex = new BlocksIndex();
+		this.imports = new Map();
+		this.importedDefs = new Map();
+		this.exports = new Map();
+		this.dependencies = new Set();
+		this.dependants = new Set();
+		this.referred = [];
+		this.dependenciesMap = new Map();
+		this.nodes = [];
+		this._text = "";
+		this.resolvedAnnotations = [];
+		this.annotations = [];
+		this._allMessages = undefined;
+		this.registry = new IdRegistry(Array.from(config.primitives?.keys() || []));
+	}
+};
+const zeroRange = {
+	start: {
+		line: 0,
+		character: 0
+	},
+	end: {
+		line: 0,
+		character: 0
+	}
+};
+
+//#endregion
+//#region packages/core/src/defaults/meta-annotations.ts
+const metaAnnotations = {
+	label: new AnnotationSpec({
+		description: "Defines a **human-readable label** for a property or entity. Useful for UI, logs, and documentation.\n\n**Example:**```atscript@meta.label \"User Name\"name: string```",
+		argument: {
+			name: "text",
+			type: "string",
+			description: "The label to be used for this field or entity."
+		}
+	}),
+	id: new AnnotationSpec({
+		description: "Marks a field as a unique identifier across multiple domains (DB, API, UI, logs).\n\n**Example:**```atscript@meta.id \"userId\"id: string```",
+		argument: {
+			optional: true,
+			name: "name",
+			type: "string",
+			description: "Custom identifier name (defaults to property name if omitted)."
+		}
+	}),
+	description: new AnnotationSpec({
+		description: "Provides a **detailed description** of a field or entity, often used in documentation.\n\n**Example:**```atscript@meta.description \"Stores the user email address\"email: string```",
+		argument: {
+			name: "text",
+			type: "string",
+			description: "Detailed description for this field or entity."
+		}
+	}),
+	documentation: new AnnotationSpec({
+		description: "Provides **multi-line documentation** for a field or entity.\n\n**Example:**```atscript@meta.documentation \"# bio\"@meta.documentation \"## documentation of bio\"@meta.documentation \"your documentation\"bio: string```",
+		multiple: true,
+		argument: {
+			name: "text",
+			type: "string",
+			description: "A line of documentation text. Multiple annotations can be used to form a full Markdown document."
+		}
+	}),
+	placeholder: new AnnotationSpec({
+		description: "Defines a **default placeholder value** for UI input fields.\n\n**Example:**```atscript@meta.placeholder \"Enter your name\"name: string```",
+		nodeType: ["prop"],
+		argument: {
+			name: "text",
+			type: "string",
+			description: "The placeholder text to display in UI forms."
+		}
+	}),
+	sensitive: new AnnotationSpec({
+		description: "Marks a field as **sensitive** (e.g., passwords, API keys), ensuring it is hidden in logs and UI.\n\n**Example:**```atscript@meta.sensitivepassword: string```",
+		nodeType: ["prop"],
+		multiple: false
+	}),
+	readonly: new AnnotationSpec({
+		description: "Marks a field as **read-only**, preventing modifications after creation.\n\n**Example:**```atscript@meta.readonlycreatedAt: date```",
+		nodeType: ["prop"],
+		multiple: false
+	})
+};
+
+//#endregion
+//#region packages/core/src/defaults/primitives.ts
+const positive = {
+	documentation: "Number that greater than or equal to zero.",
+	expect: { min: 0 }
+};
+const negative = {
+	documentation: "Number that less than or equal to zero.",
+	expect: { max: 0 }
+};
+const positiveOrNegative = {
+	positive,
+	negative
+};
+const primitives = {
+	never: { documentation: "Represents impossible type." },
+	string: {
+		type: "string",
+		documentation: "Represents textual data.",
+		extensions: {
+			email: {
+				documentation: "Represents an email address.",
+				expect: {
+					pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+					message: "Invalid email format."
+				}
+			},
+			phone: {
+				documentation: "Represents an phone number.",
+				expect: {
+					pattern: /^\+?[0-9\s-]{10,15}$/,
+					message: "Invalid phone number format."
+				}
+			},
+			date: {
+				documentation: "Represents a date string.",
+				expect: {
+					pattern: [
+						/^\d{4}-\d{2}-\d{2}$/,
+						/^\d{2}\/\d{2}\/\d{4}$/,
+						/^\d{2}-\d{2}-\d{4}$/,
+						/^\d{1,2} [A-Za-z]+ \d{4}$/
+					],
+					message: "Invalid date format."
+				}
+			},
+			isoDate: {
+				documentation: "Represents a date string in ISO format.",
+				expect: {
+					pattern: [/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?([+-]\d{2}:\d{2})$/],
+					message: "Invalid ISO date format."
+				}
+			},
+			uuid: {
+				documentation: "Represents a UUID.",
+				expect: {
+					pattern: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+					message: "Invalid UUID format."
+				}
+			}
+		}
+	},
+	number: {
+		type: "number",
+		documentation: "Represents numeric data.",
+		extensions: {
+			...positiveOrNegative,
+			single: {
+				extensions: positiveOrNegative,
+				documentation: "Represents a single-precision floating-point number."
+			},
+			double: {
+				extensions: positiveOrNegative,
+				documentation: "Represents a double-precision floating-point number."
+			},
+			int: {
+				extensions: positiveOrNegative,
+				documentation: "Represents an integer number.",
+				expect: { int: true }
+			},
+			timestamp: {
+				documentation: "Represents a timestamp.",
+				expect: { int: true }
+			}
+		}
+	},
+	boolean: {
+		type: "boolean",
+		documentation: "Represents true/false values.",
+		extensions: {
+			true: { documentation: "Represents a true value." },
+			false: { documentation: "Represents a false value." }
+		}
+	},
+	null: {
+		type: "null",
+		documentation: "Represents NULL value."
+	},
+	void: {
+		type: "void",
+		documentation: "Represents no value."
+	},
+	undefined: {
+		type: "void",
+		documentation: "Represents no value."
+	}
+};
+
+//#endregion
+//#region packages/core/src/defaults/expect-annotations.ts
+const expectAnnotations = {
+	minLength: new AnnotationSpec({
+		description: "Validates that a string or array has a minimum length.\n\n**Example:**```atscript@expect.minLength 5name: string```",
+		defType: ["array", "string"],
+		argument: {
+			name: "length",
+			type: "number",
+			description: "The minimum length of the string or array."
+		}
+	}),
+	maxLength: new AnnotationSpec({
+		description: "Validates that a string or array has a maximum length.\n\n**Example:**```atscript@expect.maxLength 5name: string```",
+		defType: ["array", "string"],
+		argument: {
+			name: "length",
+			type: "number",
+			description: "The maximum length of the string or array."
+		}
+	}),
+	min: new AnnotationSpec({
+		description: "Validates that a number is greater than or equal to a minimum value.\n\n**Example:**```atscript@expect.min 18age: number```",
+		defType: ["number"],
+		argument: {
+			name: "minValue",
+			type: "number",
+			description: "The minimum value."
+		}
+	}),
+	max: new AnnotationSpec({
+		description: "Validates that a number is less than or equal to a maximum value.\n\n**Example:**```atscript@expect.max 10count: number```",
+		defType: ["number"],
+		argument: {
+			name: "maxValue",
+			type: "number",
+			description: "The maximum value."
+		}
+	}),
+	int: new AnnotationSpec({
+		description: "Validates that a number is an integer (no decimal places).\n\n**Example:**```atscript@expect.intage: number```",
+		defType: ["number"]
+	}),
+	pattern: new AnnotationSpec({
+		description: "Validates that a string matches a specific pattern.\n\n**Example:**```atscript@expect.pattern \"[a-z]+\", \"u\"name: string```",
+		defType: ["string"],
+		multiple: true,
+		mergeStrategy: "append",
+		argument: [
+			{
+				name: "pattern",
+				type: "string",
+				description: "The regular expression pattern to match."
+			},
+			{
+				name: "flags",
+				optional: true,
+				type: "string",
+				values: [
+					"g",
+					"gi",
+					"gim",
+					"gims",
+					"gimsu",
+					"gimsuy",
+					"gimsy",
+					"gimu",
+					"gimuy",
+					"gimy",
+					"gis",
+					"gisu",
+					"gisuy",
+					"gisy",
+					"giu",
+					"giuy",
+					"giy",
+					"gm",
+					"gms",
+					"gmsu",
+					"gmsuy",
+					"gmsy",
+					"gmu",
+					"gmuy",
+					"gmy",
+					"gs",
+					"gsu",
+					"gsuy",
+					"gsy",
+					"gu",
+					"guy",
+					"gy",
+					"i",
+					"im",
+					"ims",
+					"imsu",
+					"imsuy",
+					"imsy",
+					"imu",
+					"imuy",
+					"imy",
+					"is",
+					"isu",
+					"isuy",
+					"isy",
+					"iu",
+					"iuy",
+					"iy",
+					"m",
+					"ms",
+					"msu",
+					"msuy",
+					"msy",
+					"mu",
+					"muy",
+					"my",
+					"s",
+					"su",
+					"suy",
+					"sy",
+					"u",
+					"uy",
+					"y"
+				],
+				description: "Optional flags for the regular expression."
+			},
+			{
+				name: "message",
+				optional: true,
+				type: "string",
+				description: "Optional error message to display if the validation fails."
+			}
+		],
+		validate(mainToken, args) {
+			if (args[0]) try {
+				new RegExp(args[0].text);
+				return [];
+			} catch (e) {
+				return [{
+					message: "Invalid regular expression",
+					range: args[0].range,
+					severity: 1
+				}];
+			}
+			return [];
+		}
+	})
+};
+
+//#endregion
+//#region packages/core/src/default-atscript-config.ts
+function getDefaultAtscriptConfig() {
+	const defaulTAtscriptConfig = {
+		primitives,
+		annotations: {
+			meta: { ...metaAnnotations },
+			expect: { ...expectAnnotations }
+		}
+	};
+	return defaulTAtscriptConfig;
+}
+
+//#endregion
+//#region packages/core/src/plugin/plugin-manager.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 PluginManager = class {
+	get plugins() {
+		return this.cfg.plugins ?? [];
+	}
+	async getDocConfig() {
+		if (!this._docConfig) {
+			const raw = await this.config();
+			this._docConfig = {};
+			if (raw?.primitives) {
+				this._docConfig.primitives = this._docConfig.primitives || new Map();
+				for (const [key, value] of Object.entries(raw.primitives)) this._docConfig.primitives.set(key, new SemanticPrimitiveNode(key, value));
+			}
+			if (raw?.annotations) {
+				this._docConfig.annotations = this._docConfig.annotations || {};
+				Object.assign(this._docConfig.annotations, raw.annotations);
+			}
+			this._docConfig.unknownAnnotation = raw?.unknownAnnotation;
+		}
+		return this._docConfig;
+	}
+	async config(config = this.cfg) {
+		if (!this._config) {
+			const processed = new Set();
+			config = defu(config, getDefaultAtscriptConfig());
+			const filtered = this.plugins.filter((plugin) => !processed.has(plugin.name));
+			let i = 0;
+			while (processed.size !== filtered.length) {
+				i++;
+				for (const plugin of filtered) {
+					if (processed.has(plugin.name)) continue;
+					config = defu(await plugin.config?.(config), config);
+					processed.add(plugin.name);
+				}
+				if (i > 100) throw new Error(`Too many iterations in config`);
+			}
+			this._config = config;
+		}
+		return this._config;
+	}
+	async resolve(id) {
+		let newId = id;
+		for (const plugin of this.plugins) if (plugin.resolve) newId = await plugin.resolve(id);
+		return newId;
+	}
+	async load(id) {
+		const filePath = id.startsWith("file://") ? id.slice(7) : id;
+		for (const plugin of this.plugins) if (plugin.load) {
+			const content$1 = await plugin.load(id);
+			if (content$1) return content$1;
+		}
+		const content = await readFile(filePath, "utf8");
+		return content.toString();
+	}
+	async onDocumnet(doc) {
+		for (const plugin of this.plugins) if (plugin.onDocumnet) await plugin.onDocumnet(doc);
+	}
+	async render(doc, format) {
+		const files = [];
+		for (const plugin of this.plugins) if (plugin.render) {
+			const newFiles = await plugin.render(doc, format);
+			if (newFiles?.length > 0) files.push(...newFiles.map((f) => ({
+				...f,
+				source: doc.id.startsWith("file://") ? doc.id.slice(7) : doc.id
+			})));
+		}
+		return files;
+	}
+	async buildEnd(output, format, repo) {
+		for (const plugin of this.plugins) if (plugin.buildEnd) await plugin.buildEnd(output, format, repo);
+	}
+	async loopInAnnotationsSpec(cb) {
+		const config = await this.config();
+		const annotations$1 = config.annotations || {};
+		return this._loopInAnnotationsSpec(annotations$1, cb);
+	}
+	_loopInAnnotationsSpec(annotations$1, cb, prefix) {
+		for (const [key, value] of Object.entries(annotations$1)) if (isAnnotationSpec(value)) cb(prefix ? `${prefix}.${key}` : key, value);
+else this._loopInAnnotationsSpec(value, cb, prefix ? `${prefix}.${key}` : key);
+	}
+	constructor(cfg) {
+		_define_property$2(this, "cfg", void 0);
+		_define_property$2(this, "_config", void 0);
+		_define_property$2(this, "name", void 0);
+		_define_property$2(this, "_docConfig", void 0);
+		this.cfg = cfg;
+		this.name = "plugin-manager";
+	}
+};
+
+//#endregion
+//#region packages/core/src/repo.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 AtscriptRepo = class {
+	getSharedPluginManager() {
+		return this.sharedPluginManager?.manager;
+	}
+	async getPrimitivesTags() {
+		const manager = await this.getSharedPluginManager();
+		if (!manager) return undefined;
+		const docConfig = await manager.getDocConfig();
+		const primitives$1 = Array.from(docConfig.primitives?.entries() || []);
+		const tags = [];
+		const processed = new Set();
+		for (const [, primitive] of primitives$1) tags.push(...primitive.getAllTags(processed));
+		return new Set(tags);
+	}
+	async getUsedAnnotations() {
+		const manager = await this.getSharedPluginManager();
+		const annotations$1 = {};
+		if (manager) await manager.loopInAnnotationsSpec((name, spec) => {
+			const types = [];
+			const multiple = !!spec.config.multiple;
+			if (Array.isArray(spec.config.argument)) {
+				const o = {
+					type: "object",
+					props: {}
+				};
+				for (const a of spec.arguments) o.props[a.name] = {
+					type: a.type,
+					optional: a.optional
+				};
+				types.push(o);
+			} else if (spec.config.argument) types.push({
+				type: spec.config.argument.type,
+				optional: spec.config.argument.optional
+			});
+else types.push({ type: "boolean" });
+			annotations$1[name] = {
+				multiple,
+				fromSpec: true,
+				typeSet: new Set(),
+				types
+			};
+		});
+		for (const doc of Array.from(this.atscripts.values())) {
+			const awaited = await doc;
+			for (const { name, token, args } of awaited.annotations) {
+				if (annotations$1[name]?.fromSpec) continue;
+				if (!annotations$1[name]) {
+					let types = [];
+					let multiple = false;
+					annotations$1[name] = {
+						multiple,
+						fromSpec: false,
+						typeSet: new Set(),
+						types
+					};
+				}
+				const isArray$1 = token.parentNode.countAnnotations(name) > 1;
+				if (isArray$1) annotations$1[name].multiple = true;
+				for (const arg of args) if (arg.type === "text") {
+					if (!annotations$1[name].typeSet.has("string")) {
+						annotations$1[name].typeSet.add("string");
+						annotations$1[name].types.push({ type: "string" });
+					}
+				} else if (arg.type === "number") {
+					if (!annotations$1[name].typeSet.has("number")) {
+						annotations$1[name].typeSet.add("number");
+						annotations$1[name].types.push({ type: "number" });
+					}
+				} else if (arg.type === "identifier" && ["true", "false"].includes(arg.text)) {
+					if (!annotations$1[name].typeSet.has("boolean")) {
+						annotations$1[name].typeSet.add("boolean");
+						annotations$1[name].types.push({ type: "boolean" });
+					}
+				} else if (!annotations$1[name].typeSet.has("unknown")) {
+					annotations$1[name].typeSet.add("unknown");
+					annotations$1[name].types.push({ type: "unknown" });
+				}
+				if (args.length === 0 && !annotations$1[name].typeSet.has("boolean")) {
+					annotations$1[name].typeSet.add("boolean");
+					annotations$1[name].types.push({ type: "boolean" });
+				}
+			}
+		}
+		return annotations$1;
+	}
+	async loadPluginManagerFor(id) {
+		if (this.sharedConfig) {
+			if (!this.sharedPluginManager) this.sharedPluginManager = {
+				manager: new PluginManager(this.sharedConfig),
+				dependants: new Set()
+			};
+			return this.sharedPluginManager;
+		}
+		const configFile = await resolveConfigFile(id, this.root);
+		if (configFile) {
+			const globalPathToConfig = path.join(this.root, configFile);
+			if (!this.configFiles.has(globalPathToConfig)) {
+				const rawConfigPromise = loadConfig(configFile, this.configFormat);
+				this.configFiles.set(globalPathToConfig, rawConfigPromise);
+			}
+			const rawConfig = await this.configFiles.get(globalPathToConfig);
+			if (!rawConfig.rootDir) rawConfig.rootDir = path.dirname(configFile);
+			const manager = new PluginManager(rawConfig);
+			await manager.getDocConfig();
+			return {
+				file: globalPathToConfig,
+				manager,
+				dependants: new Set()
+			};
+		} else {
+			const manager = new PluginManager({ rootDir: process.cwd() });
+			await manager.getDocConfig();
+			return {
+				manager,
+				dependants: new Set()
+			};
+		}
+	}
+	async resolveConfig(id) {
+		let config = this.configs.get(id);
+		if (!config) {
+			config = this.loadPluginManagerFor(id);
+			config.then((c) => {
+				c.dependants.add(id);
+			});
+			this.configs.set(id, config);
+		}
+		return config;
+	}
+	async openDocument(id, text$2) {
+		let atscript = this.atscripts.get(id);
+		if (atscript) {
+			if (text$2) atscript.then((d) => {
+				d.update(text$2);
+				return d;
+			});
+		} else {
+			atscript = this._openDocument(id, text$2);
+			atscript.catch(() => {
+				this.atscripts.delete(id);
+			});
+			this.atscripts.set(id, atscript);
+		}
+		return atscript;
+	}
+	async _openDocument(id, text$2) {
+		const { manager } = await this.resolveConfig(id);
+		const newId = await manager.resolve(id);
+		if (!newId) throw new Error(`Document not resolved: ${id}`);
+		const content = text$2 || await manager.load(newId);
+		if (typeof content !== "string") throw new Error(`Document not found: ${newId}`);
+		const atscript = new AtscriptDoc(id, await manager.getDocConfig(), manager);
+		atscript.update(content);
+		await manager.onDocumnet(atscript);
+		return atscript;
+	}
+	async checkDoc(atscript) {
+		await this.checkImports(atscript);
+	}
+	async checkImports(atscript) {
+		const promise = Promise.all(Array.from(atscript.imports.values(), async ({ from, imports }) => this.checkImport(atscript, from, imports)));
+		const results = await promise;
+		atscript.updateDependencies(results.filter(Boolean));
+	}
+	async checkImport(atscript, from, imports) {
+		const forId = resolveAtscriptFromPath(from.text, atscript.id);
+		if (forId === atscript.id) {
+			const messages = atscript.getDiagMessages();
+			messages.push({
+				severity: 1,
+				message: "\"import\" cannot import itself",
+				range: from.range
+			});
+			return;
+		}
+		const errors = [];
+		let external;
+		try {
+			external = await this.openDocument(forId);
+			for (const token of imports) if (!external.exports.has(token.text)) errors.push({
+				severity: 1,
+				message: `"${from.text}" has no exported member "${token.text}"`,
+				range: token.range
+			});
+		} catch (error) {
+			errors.push({
+				severity: 1,
+				message: `"${from.text}" not found`,
+				range: from.range
+			});
+		}
+		if (errors.length > 0) {
+			const messages = atscript.getDiagMessages();
+			messages.push(...errors);
+		}
+		return external;
+	}
+	constructor(root$1 = process.cwd(), sharedConfig) {
+		_define_property$1(this, "root", void 0);
+		_define_property$1(this, "sharedConfig", void 0);
+		_define_property$1(this, "configFormat", void 0);
+		/**
+		* Configs cache
+		*/ _define_property$1(this, "configs", void 0);
+		/**
+		* .as Documents cache
+		*/ _define_property$1(this, "atscripts", void 0);
+		_define_property$1(this, "sharedPluginManager", void 0);
+		/**
+		* cache for raw content of config files
+		*/ _define_property$1(this, "configFiles", void 0);
+		this.root = root$1;
+		this.sharedConfig = sharedConfig;
+		this.configs = new Map();
+		this.atscripts = new Map();
+		this.configFiles = new Map();
+	}
+};
+
+//#endregion
+//#region packages/core/src/plugin/types.ts
+const createAtscriptPlugin = (plugin) => plugin;
+
+//#endregion
+//#region packages/core/src/build.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;
+}
+async function build(config) {
+	const rootDir = config.rootDir ? config.rootDir.startsWith("/") ? config.rootDir : path$1.join(process.cwd(), config.rootDir) : process.cwd();
+	config.rootDir = rootDir;
+	const repo = new AtscriptRepo(rootDir, config);
+	const entries = [];
+	if (config.entries && config.entries.length > 0) for (const entry of config.entries) entries.push(path$1.join(rootDir, entry));
+else {
+		const includes = config.include && config.include.length > 0 ? config.include : ["**/*.as"];
+		const excludes = config.exclude && config.exclude.length > 0 ? config.exclude : ["node_modules"];
+		const found = await glob(includes, {
+			cwd: rootDir,
+			absolute: true,
+			ignore: excludes
+		});
+		entries.push(...found);
+	}
+	const documents = [];
+	for (const entry of entries) documents.push(await repo.openDocument("file://" + entry));
+	return new BuildRepo(rootDir, repo, documents.filter(Boolean));
+}
+var BuildRepo = class {
+	async diagnostics() {
+		const docMessages = new Map();
+		for (const document of this.docs) {
+			await this.repo.checkDoc(document);
+			docMessages.set(document.id, document.getDiagMessages());
+		}
+		return docMessages;
+	}
+	async generate(config, docs = this.docs) {
+		const outFiles = [];
+		for (const document of docs) {
+			const out = await document.render(config.format);
+			if (out?.length) outFiles.push(...out);
+		}
+		for (const outFile of outFiles) {
+			const docPath = outFile.source.replace(/^file:\/\//, "");
+			if (config.outDir) {
+				const rel = path$1.relative(this.rootDir, docPath);
+				const relDir = path$1.dirname(rel);
+				outFile.target = path$1.join(this.rootDir, config.outDir, relDir, outFile.fileName);
+			} else outFile.target = path$1.join(path$1.dirname(docPath), outFile.fileName);
+		}
+		if (this.repo.sharedConfig && this.docs === docs && this.docs[0]) {
+			const { manager } = await this.repo.loadPluginManagerFor(this.docs[0].id);
+			await manager.buildEnd(outFiles, config.format, this.repo);
+		}
+		return outFiles;
+	}
+	async write(config, docs = this.docs) {
+		const outFiles = await this.generate(config, docs);
+		for (const o of outFiles) if (o.target) {
+			await mkdir(path$1.dirname(o.target), { recursive: true });
+			writeFile(o.target, o.content);
+		}
+		return outFiles;
+	}
+	constructor(rootDir, repo, docs) {
+		_define_property(this, "rootDir", void 0);
+		_define_property(this, "repo", void 0);
+		_define_property(this, "docs", void 0);
+		this.rootDir = rootDir;
+		this.repo = repo;
+		this.docs = docs;
+	}
+};
+
+//#endregion
+export { $n, AnnotationSpec, AtscriptDoc, AtscriptRepo, BuildRepo, PluginManager, SemanticArrayNode, SemanticConstNode, SemanticGroup, SemanticImportNode, SemanticInterfaceNode, SemanticNode, SemanticPrimitiveNode, SemanticPropNode, SemanticRefNode, SemanticStructureNode, SemanticTupleNode, SemanticTypeNode, Token, build, createAtscriptPlugin, defineConfig, getRelPath, isAnnotationSpec, isArray, isConst, isGroup, isImport, isInterface, isPrimitive, isProp, isRef, isStructure, isTuple, isType, loadConfig, loadTsConfig, resolveAnnotation, resolveAtscriptFromPath, resolveConfigFile };