@atscript/typescript 0.0.1

package/dist/cli.cjs

@@ -0,0 +1,726 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const moost = __toESM(require("moost"));
+const __moostjs_event_cli = __toESM(require("@moostjs/event-cli"));
+const path = __toESM(require("path"));
+const __atscript_core = __toESM(require("@atscript/core"));
+const fs = __toESM(require("fs"));
+
+//#region packages/typescript/src/codegen/code-printer.ts
+function _define_property$3(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var CodePrinter = class {
+	/**
+	* Write text with NO automatic newline.
+	* If current line is empty, we prepend indentation.
+	*/ write(...text) {
+		if (!this.currentLine) this.currentLine = this.indentString();
+		this.currentLine += text.join("");
+		return this;
+	}
+	/**
+	* Write text and then finalize this line with a newline.
+	* Implemented by calling `write(...)` + push line + reset `currentLine`.
+	*/ writeln(...text) {
+		this.write(...text);
+		this.lines.push(this.currentLine);
+		this.currentLine = "";
+		return this;
+	}
+	/**
+	* Open a block with an opening/closing pair, e.g. "{}" or "()".
+	* By default, places the opening delimiter on the current line (no extra newline).
+	*/ block(pair) {
+		return this.doBlock(pair, false);
+	}
+	/**
+	* Same as `block()`, but adds a newline after writing the opening delimiter.
+	*/ blockln(pair) {
+		return this.doBlock(pair, true);
+	}
+	/**
+	* Close the most recent block. By default, closing delimiter goes on the current line.
+	*/ pop() {
+		return this.doPop(false);
+	}
+	/**
+	* Same as `pop()`, but puts the closing delimiter on a new line.
+	*/ popln() {
+		return this.doPop(true);
+	}
+	/**
+	* Increase indentation by one level.
+	*/ indent() {
+		this.indentLevel++;
+		return this;
+	}
+	/**
+	* Decrease indentation by one level (never below 0).
+	*/ unindent() {
+		this.indentLevel = Math.max(0, this.indentLevel - 1);
+		return this;
+	}
+	render() {
+		return this.toString();
+	}
+	/**
+	* Return the entire code as a string. Removes any half-finished current line if empty.
+	*/ toString() {
+		if (this.currentLine.trim() !== "") this.lines.push(this.currentLine);
+else if (this.currentLine.length > 0) this.lines.push(this.currentLine);
+		return this.lines.join("\n");
+	}
+	doBlock(pair, withNewLine) {
+		if (pair.length < 2) throw new Error(`Block pair must have at least 2 chars, e.g. "{}" or "()". Got "${pair}"`);
+		const opening = pair[0];
+		const closing = pair[pair.length - 1];
+		this.write(opening);
+		this.blockStack.push(closing);
+		if (withNewLine) this.writeln();
+		this.indent();
+		return this;
+	}
+	doPop(withNewLine) {
+		if (!this.blockStack.length) throw new Error("No block to pop (stack is empty).");
+		const closing = this.blockStack.pop();
+		this.unindent();
+		if (withNewLine) this.writeln(closing);
+else this.write(closing);
+		return this;
+	}
+	indentString() {
+		return " ".repeat(this.indentLevel * this.indentSize);
+	}
+	constructor() {
+		_define_property$3(this, "lines", []);
+		_define_property$3(this, "currentLine", "");
+		_define_property$3(this, "indentLevel", 0);
+		_define_property$3(this, "indentSize", 2);
+		_define_property$3(this, "blockStack", []);
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/codegen/base-renderer.ts
+function _define_property$2(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var BaseRenderer = class extends CodePrinter {
+	pre() {}
+	post() {}
+	render() {
+		this.pre();
+		for (const node of this.doc.nodes) this.renderNode(node);
+		this.post();
+		return this.toString();
+	}
+	renderInterface(node) {}
+	renderType(node) {}
+	transformFromPath(path$3) {
+		return path$3 + ".as";
+	}
+	renderImport(node) {
+		const def = node.getDefinition();
+		const refs = [];
+		const from = this.transformFromPath(node.token("path").text);
+		let isUnusedImport = true;
+		if ((0, __atscript_core.isGroup)(def)) {
+			for (const child of def.unwrap()) if ((0, __atscript_core.isRef)(child) && !this.unused.has(child.id)) {
+				const node$1 = child;
+				refs.push(node$1.id);
+				isUnusedImport = false;
+			}
+		} else if ((0, __atscript_core.isRef)(def) && !this.unused.has(def.id)) {
+			refs.push(def.id);
+			isUnusedImport = false;
+		}
+		if (!isUnusedImport) this.writeln(`import { ${refs.join(", ")} } from "${from}"`);
+	}
+	renderNode(node) {
+		switch (node.entity) {
+			case "interface": {
+				this.renderInterface(node);
+				break;
+			}
+			case "type": {
+				this.renderType(node);
+				break;
+			}
+			case "import": {
+				this.renderImport(node);
+				break;
+			}
+			default: break;
+		}
+	}
+	constructor(doc) {
+		super(), _define_property$2(this, "doc", void 0), _define_property$2(this, "unused", void 0), this.doc = doc;
+		this.unused = new Set(this.doc.getUnusedTokens().map((t) => t.text));
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/codegen/utils.ts
+function wrapProp(name) {
+	const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+	if (!validIdentifier.test(name)) return `"${escapeQuotes(name)}"`;
+	return name;
+}
+function escapeQuotes(str) {
+	return str.replace(/"/g, "\\\"");
+}
+
+//#endregion
+//#region packages/typescript/src/codegen/type-renderer.ts
+var TypeRenderer = class extends BaseRenderer {
+	pre() {
+		this.writeln("// prettier-ignore-start");
+		this.writeln("/* eslint-disable */");
+		this.writeln(`/// <reference path="./${this.doc.name}" />`);
+		this.writeln("/**");
+		this.writeln(" * 🪄 This file was generated by Atscript");
+		this.writeln(" * Do not edit this file!");
+		this.writeln(" */");
+		this.writeln();
+		this.writeln("import type { TAtscriptTypeObject, TAtscriptTypeComplex, TAtscriptTypeFinal, TAtscriptTypeArray, TMetadataMap, Validator } from \"@atscript/typescript\"");
+	}
+	post() {
+		this.writeln("// prettier-ignore-end");
+	}
+	renderTypeDef(def) {
+		if (!def) {
+			this.write("unknown");
+			return;
+		}
+		if ((0, __atscript_core.isStructure)(def)) return this.renderStructure(def);
+		if ((0, __atscript_core.isGroup)(def)) {
+			const tuple = def.entity === "tuple";
+			const operator = tuple ? ", " : ` ${def.op} `;
+			const children = def.unwrap();
+			const hasSubgroup = !tuple && children.some((c) => c.entity === "group");
+			this.write(tuple ? "[" : hasSubgroup ? "(" : "");
+			this.renderTypeDef(def.first);
+			for (const child of children.slice(1)) {
+				this.write(operator);
+				this.renderTypeDef(child);
+			}
+			return this.write(tuple ? "]" : hasSubgroup ? ")" : "");
+		}
+		if ((0, __atscript_core.isConst)(def)) {
+			const name = def.token("identifier")?.type === "number" ? def.id : `"${escapeQuotes(def.id)}"`;
+			return this.write(name);
+		}
+		if ((0, __atscript_core.isRef)(def)) {
+			const node = def;
+			const unwound = this.doc.unwindType(node.id, node.chain);
+			if ((0, __atscript_core.isPrimitive)(unwound?.def)) {
+				this.write(renderPrimitiveTypeDef(unwound.def.config.type));
+				if (node.hasChain) this.write(` /* ${node.chain.map((c) => c.text).join(".")} */`);
+				return;
+			}
+			let name = node.id;
+			for (const c of node.chain) name += `["${escapeQuotes(c.text)}"]`;
+			return this.write(name);
+		}
+		if ((0, __atscript_core.isArray)(def)) {
+			const node = def;
+			const def2 = node.getDefinition();
+			const isGrp = def2?.entity === "group";
+			if (isGrp) this.write("(");
+			this.renderTypeDef(def2);
+			if (isGrp) this.write(")");
+			return this.write("[]");
+		}
+	}
+	renderStructure(struct, asClass) {
+		this.blockln("{}");
+		for (const prop of Array.from(struct.props.values())) {
+			const optional = !!prop.token("optional");
+			this.write(wrapProp(prop.id), optional ? "?" : "", ": ");
+			this.renderTypeDef(prop.getDefinition());
+			this.writeln();
+		}
+		if (asClass) {
+			this.writeln("static __is_anscript_annotated_type: true");
+			this.writeln(`static type: TAtscriptTypeObject<keyof ${asClass}>`);
+			this.writeln(`static metadata: TMetadataMap<AtscriptMetadata>`);
+			this.writeln(`static validator: () => Validator`);
+		}
+		this.pop();
+	}
+	renderInterface(node) {
+		this.writeln();
+		const exported = node.token("export")?.text === "export";
+		this.renderJsDoc(node);
+		this.write(exported ? "export declare " : "declare ");
+		this.write(`class ${node.id} `);
+		const struct = node.getDefinition();
+		if (struct?.entity === "structure") this.renderStructure(struct, node.id);
+else this.writeln("{}");
+		this.writeln();
+	}
+	renderType(node) {
+		this.writeln();
+		const exported = node.token("export")?.text === "export";
+		this.renderJsDoc(node);
+		this.write(exported ? "export " : "declare ");
+		this.write(`type ${node.id} = `);
+		this.renderTypeDef(node.getDefinition());
+		this.writeln();
+		this.renderTypeNamespace(node);
+	}
+	renderTypeNamespace(node) {
+		this.write(`declare namespace ${node.id} `);
+		this.blockln("{}");
+		const def = node.getDefinition();
+		let typeDef = "TAtscriptTypeDef";
+		if (def) {
+			let realDef = def;
+			if ((0, __atscript_core.isRef)(def)) realDef = this.doc.unwindType(def.id, def.chain)?.def || realDef;
+			realDef = this.doc.mergeIntersection(realDef);
+			if ((0, __atscript_core.isStructure)(realDef) || (0, __atscript_core.isInterface)(realDef)) typeDef = `TAtscriptTypeObject<keyof ${node.id}}>`;
+else if ((0, __atscript_core.isGroup)(realDef)) typeDef = "TAtscriptTypeComplex";
+else if ((0, __atscript_core.isArray)(realDef)) typeDef = "TAtscriptTypeArray";
+else if ((0, __atscript_core.isPrimitive)(realDef)) typeDef = "TAtscriptTypeFinal";
+		}
+		this.writeln(`const __is_anscript_annotated_type: true`);
+		this.writeln(`const type: ${typeDef}`);
+		this.writeln(`const metadata: TMetadataMap<AtscriptMetadata>`);
+		this.writeln(`const validator: () => Validator`);
+		this.popln();
+	}
+	renderJsDoc(node) {
+		const range = node.token("identifier")?.range;
+		const rangeStr = range ? `:${range.start.line + 1}:${range.start.character + 1}` : "";
+		this.writeln(`/**`);
+		this.writeln(` * Atscript ${node.entity} **${node.id}**`);
+		this.writeln(` * @see {@link ./${this.doc.name}${rangeStr}}`);
+		this.writeln(` */`);
+	}
+};
+function renderPrimitiveTypeDef(def) {
+	if (!def) return "unknown";
+	if (typeof def === "string") return def === "void" ? "undefined" : def;
+	switch (def.kind) {
+		case "final": return def.value === "void" ? "undefined" : def.value;
+		case "union": return def.items.map(renderPrimitiveTypeDef).join(" | ");
+		case "intersection": return def.items.map(renderPrimitiveTypeDef).join(" & ");
+		case "tuple": return `[${def.items.map(renderPrimitiveTypeDef).join(", ")}]`;
+		case "array": return `${renderPrimitiveTypeDef(def.of)}[]`;
+		case "object": {
+			const props = Object.entries(def.props).map(([key, val]) => `${wrapProp(key)}${typeof val === "object" && val.optional ? "?" : ""}: ${renderPrimitiveTypeDef(val)}`).join("; ");
+			return `{ ${props} }`;
+		}
+		default: return "unknown";
+	}
+}
+
+//#endregion
+//#region packages/typescript/src/codegen/js-renderer.ts
+function _define_property$1(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var JsRenderer = class extends BaseRenderer {
+	pre() {
+		this.writeln("import { defineAnnotatedType as $ } from \"@atscript/typescript\"");
+	}
+	post() {
+		for (const node of this.postAnnotate) {
+			this.annotateType(node.getDefinition(), node.id);
+			this.indent().defineMetadata(node).unindent();
+			this.writeln();
+		}
+		super.post();
+	}
+	renderInterface(node) {
+		this.writeln();
+		const exported = node.token("export")?.text === "export";
+		this.write(exported ? "export " : "");
+		this.write(`class ${node.id} `);
+		this.blockln("{}");
+		this.writeln("static __is_anscript_annotated_type = true");
+		this.writeln("static type = {}");
+		this.writeln("static metadata = new Map()");
+		this.popln();
+		this.postAnnotate.push(node);
+		this.writeln();
+	}
+	renderType(node) {
+		this.writeln();
+		const exported = node.token("export")?.text === "export";
+		this.write(exported ? "export " : "");
+		this.write(`class ${node.id} `);
+		this.blockln("{}");
+		this.writeln("static __is_anscript_annotated_type = true");
+		this.writeln("static type = {}");
+		this.writeln("static metadata = new Map()");
+		this.popln();
+		this.postAnnotate.push(node);
+		this.writeln();
+	}
+	annotateType(_node, name) {
+		if (!_node) return this;
+		const node = this.doc.mergeIntersection(_node);
+		let kind = node.entity;
+		switch (node.entity) {
+			case "ref": {
+				const ref = node;
+				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
+				if ((0, __atscript_core.isPrimitive)(decl)) {
+					this.annotateType(decl, name);
+					return this;
+				}
+				const chain = ref.hasChain ? `, [${ref.chain.map((c) => `"${escapeQuotes(c.text)}"`).join(", ")}]` : "";
+				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${ref.id}${chain})`).unindent();
+				return this;
+			}
+			case "primitive": {
+				this.definePrimitive(node, name);
+				return this;
+			}
+			case "const": {
+				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().defineConst(node).unindent();
+				return this;
+			}
+			case "structure": {
+				this.writeln(`$("object"${name ? `, ${name}` : ""})`).indent().defineObject(node).unindent();
+				return this;
+			}
+			case "group": {
+				kind = node.op === "|" ? "union" : "intersection";
+				this.writeln(`$("${kind}"${name ? `, ${name}` : ""})`).indent().defineGroup(node).unindent();
+				return this;
+			}
+			case "tuple": {
+				this.writeln(`$("tuple"${name ? `, ${name}` : ""})`).indent().defineGroup(node).unindent();
+				return this;
+			}
+			case "array": {
+				this.writeln(`$("array"${name ? `, ${name}` : ""})`).indent().defineArray(node).unindent();
+				return this;
+			}
+			default: {
+				console.log("!!!!!!! UNKNOWN ", node.entity);
+				return this;
+			}
+		}
+	}
+	defineConst(node) {
+		const t = node.token("identifier")?.type;
+		const designType = t === "text" ? "string" : t === "number" ? "number" : "unknown";
+		const type = t === "text" ? "String" : t === "number" ? "Number" : "undefined";
+		this.writeln(`.designType("${escapeQuotes(designType)}")`);
+		this.writeln(`.value(${t === "text" ? `"${escapeQuotes(node.id)}"` : node.id})`);
+		return this;
+	}
+	definePrimitive(node, name) {
+		this.renderPrimitiveDef(node.id === "never" ? "never" : node.config.type, name);
+		this.writeln(`  .tags(${Array.from(node.tags).map((f) => `"${escapeQuotes(f)}"`).join(", ")})`);
+		return this;
+	}
+	renderPrimitiveDef(def, name) {
+		const d = (t) => [`"${t || ""}"`, name].filter(Boolean).join(", ").replace(/^""$/, "");
+		if (!def) return this.writeln(`$(${d()}).designType("any")`);
+		if (typeof def === "string") return this.writeln(`$(${d()}).designType("${def === "void" ? "undefined" : def}")`);
+		switch (def.kind) {
+			case "final": return this.writeln(`$(${d()}).designType("${def.value === "void" ? "undefined" : def.value}")`);
+			case "union":
+			case "intersection":
+			case "tuple":
+				this.writeln(`$(${d(def.kind)})`);
+				this.indent();
+				for (const itemDef of def.items) {
+					this.write(`.item(`);
+					this.indent();
+					this.renderPrimitiveDef(itemDef);
+					this.writeln(".$type");
+					this.unindent();
+					this.write(`)`);
+				}
+				this.unindent();
+				return;
+			case "array":
+				this.writeln(`$(${d("array")})`);
+				this.indent();
+				this.write(".of(");
+				this.indent();
+				this.renderPrimitiveDef(def.of);
+				this.writeln(`.$type`);
+				this.unindent();
+				this.writeln(`)`);
+				this.unindent();
+				return;
+			case "object":
+				this.writeln(`$(${d("object")})`);
+				this.indent();
+				for (const [key, propDef] of Object.entries(def.props)) {
+					const optional = typeof propDef === "object" && propDef.optional;
+					this.writeln(`.prop(`);
+					this.indent();
+					this.writeln(`"${escapeQuotes(key)}",`);
+					this.renderPrimitiveDef(propDef);
+					if (optional) this.writeln(".optional()");
+					this.writeln(".$type");
+					this.unindent();
+					this.write(`)`);
+				}
+				this.unindent();
+				return;
+			default: return this.writeln(`$(${d()}).designType("any")`);
+		}
+	}
+	defineObject(node) {
+		const props = Array.from(node.props.values());
+		for (const prop of props) {
+			const optional = !!prop.token("optional");
+			this.writeln(`.prop(`);
+			this.indent();
+			this.writeln(`"${escapeQuotes(prop.id)}",`);
+			this.annotateType(prop.getDefinition());
+			this.indent().defineMetadata(prop).unindent();
+			if (optional) this.writeln("  .optional()");
+			this.writeln("  .$type");
+			this.unindent();
+			this.write(`)`);
+		}
+		this.writeln();
+		return this;
+	}
+	defineGroup(node) {
+		const items = node.unwrap();
+		for (const item of items) this.write(".item(").indent().annotateType(item).write("  .$type").writeln(`)`).unindent();
+		return this;
+	}
+	defineArray(node) {
+		this.write(".of(").indent().annotateType(node.getDefinition()).write("  .$type").writeln(`)`).unindent();
+		return this;
+	}
+	defineMetadata(node) {
+		const annotations = this.doc.evalAnnotationsForNode(node);
+		annotations?.forEach((an) => {
+			this.resolveAnnotationValue(node, an);
+		});
+		return this;
+	}
+	resolveAnnotationValue(node, an) {
+		const spec = this.doc.resolveAnnotation(an.name);
+		let targetValue = "true";
+		let multiple = false;
+		if (spec) {
+			multiple = spec.config.multiple;
+			const length = spec.arguments.length;
+			if (length !== 0) if (Array.isArray(spec.config.argument)) {
+				targetValue = "{ ";
+				let i = 0;
+				for (const aSpec of spec.arguments) {
+					if (an.args[i]) targetValue += `${wrapProp(aSpec.name)}: ${aSpec.type === "string" ? `"${escapeQuotes(an.args[i]?.text)}"` : an.args[i]?.text}${i === length - 1 ? "" : ", "} `;
+else {}
+					i++;
+				}
+				targetValue += "}";
+			} else {
+				const aSpec = spec.arguments[0];
+				if (an.args[0]) targetValue = aSpec.type === "string" ? `"${escapeQuotes(an.args[0]?.text)}"` : an.args[0]?.text;
+else targetValue = "true";
+			}
+		} else {
+			multiple = node.countAnnotations(an.name) > 1 || an.args.length > 1;
+			if (an.args.length) targetValue = an.args[0].type === "text" ? `"${escapeQuotes(an.args[0].text)}"` : an.args[0].text;
+		}
+		if (multiple) this.writeln(`.annotate("${escapeQuotes(an.name)}", ${targetValue}, true)`);
+else this.writeln(`.annotate("${escapeQuotes(an.name)}", ${targetValue})`);
+	}
+	constructor(...args) {
+		super(...args), _define_property$1(this, "postAnnotate", []);
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/plugin.ts
+const tsPlugin = () => {
+	return {
+		name: "typesccript",
+		render(doc, format) {
+			if (format === "dts") return [{
+				fileName: `${doc.name}.d.ts`,
+				content: new TypeRenderer(doc).render()
+			}];
+			if (format === "js") return [{
+				fileName: `${doc.name}.js`,
+				content: new JsRenderer(doc).render()
+			}];
+		},
+		async buildEnd(output, format, repo) {
+			if (format === "dts") {
+				const annotations = await repo.getUsedAnnotations();
+				const tags = await repo.getPrimitivesTags() || new Set();
+				let rendered = [];
+				for (const [key, val] of Object.entries(annotations)) {
+					const multiple = val.multiple;
+					let typeLine = Array.from(val.types).map((t) => {
+						if (t.type === "object") return `{ ${Object.entries(t.props).map(([k, v]) => `${wrapProp(k)}${v.optional ? "?" : ""}: ${v.type}`).join(", ")} }`;
+else return t.optional ? `${t.type} | true` : t.type;
+					}).join(" | ");
+					rendered.push(`${wrapProp(key)}: ${multiple ? "(" : ""}${typeLine}${multiple ? ")[]" : ""}`);
+				}
+				let renderedTags = Array.from(tags).map((f) => `"${escapeQuotes(f)}"`).join(" | ");
+				output.push({
+					content: "/**\n * 🪄 This file was generated by Atscript\n * It is generated based on annotations used in this project\n * Do not edit this file!\n *\n * Use `npx asc -f dts` command to re-generate this file\n */\nexport {}\n\ndeclare global {\n  interface AtscriptMetadata {\n    " + rendered.join("\n    ") + "\n  }\n" + "  type AtscriptPrimitiveTags = " + renderedTags + "\n" + "}\n",
+					fileName: "atscript.d.ts",
+					source: "",
+					target: path.default.join(repo.root, "atscript.d.ts")
+				});
+			}
+		}
+	};
+};
+
+//#endregion
+//#region packages/typescript/src/cli/commands.controller.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;
+}
+function _ts_decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+var Commands = class {
+	async default(configFile, format) {
+		const config = await this.getConfig(configFile);
+		if (format) config.format = format;
+		this.logger.log(`Format: ${"\x1B[36m"}${config.format}${"\x1B[39m"}`);
+		const builder = await (0, __atscript_core.build)(config);
+		const out = await builder.write(config);
+		for (const { target } of out) this.logger.log(`✅ created ${"\x1B[32m"}${target}${"\x1B[39m"}`);
+	}
+	async getConfig(configFile) {
+		const root = process.cwd();
+		if (configFile) {
+			const c = path.default.join(root, configFile);
+			if (!(0, fs.existsSync)(c)) {
+				this.logger.error(`Config file ${"\x1B[4m"}${configFile}${"\x1B[24m"} not found`);
+				process.exit(1);
+			}
+			this.logger.log(`Using config file ${"\x1B[36m"}${configFile}${"\x1B[39m"}`);
+			return (0, __atscript_core.loadConfig)(c);
+		} else {
+			const resolved = await (0, __atscript_core.resolveConfigFile)(root);
+			if (resolved) {
+				this.logger.log(`Using config file ${"\x1B[36m"}${resolved}${"\x1B[39m"}`);
+				return (0, __atscript_core.loadConfig)(resolved);
+			}
+			this.logger.log(`No atscript config file found`);
+			return {
+				format: "dts",
+				plugins: [tsPlugin()]
+			};
+		}
+	}
+	constructor(logger) {
+		_define_property(this, "logger", void 0);
+		this.logger = logger;
+	}
+};
+_ts_decorate([
+	(0, __moostjs_event_cli.Cli)(""),
+	(0, moost.Description)("Builds .as files using --config and --format"),
+	(0, __moostjs_event_cli.CliExample)("-c atscript.config.js", "Build .as files using atscript.config.js"),
+	(0, __moostjs_event_cli.CliExample)("-f dts", "Build \"d.ts\" files for \".as\" files"),
+	_ts_param(0, (0, __moostjs_event_cli.CliOption)("c", "config")),
+	_ts_param(0, (0, moost.Optional)()),
+	_ts_param(0, (0, moost.Description)("Path to config file")),
+	_ts_param(1, (0, __moostjs_event_cli.CliOption)("f", "format")),
+	_ts_param(1, (0, moost.Optional)()),
+	_ts_param(1, (0, moost.Description)("Output format (js|dts), default: \"dts\"")),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [String, String]),
+	_ts_metadata("design:returntype", Promise)
+], Commands.prototype, "default", null);
+Commands = _ts_decorate([
+	(0, moost.Controller)(),
+	_ts_param(0, (0, moost.InjectMoostLogger)("asc")),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [typeof moost.TConsoleBase === "undefined" ? Object : moost.TConsoleBase])
+], Commands);
+
+//#endregion
+//#region packages/typescript/src/cli/cli.ts
+const app = new moost.Moost();
+const cli = new __moostjs_event_cli.MoostCli({
+	debug: false,
+	wooksCli: { cliHelp: { name: "asc" } },
+	globalCliOptions: [{
+		keys: ["help"],
+		description: "Display instructions for the command."
+	}]
+});
+app.adapter(cli);
+app.registerControllers(Commands);
+app.applyGlobalInterceptors((0, __moostjs_event_cli.cliHelpInterceptor)({
+	colors: true,
+	lookupLevel: 3
+}));
+app.init();
+
+//#endregion