llmz 0.6.0 → 0.6.2

package/dist/typings-CrBa7Tyy.js

@@ -0,0 +1,743 @@
+import { n as __exportAll } from "./rolldown-runtime-EAsCxrDo.js";
+import { a as getMultilineComment, f as toPropertyKey, n as escapeString } from "./utils-UBeAFeEI.js";
+import { r as CodeFormattingError } from "./errors-Cg1G0Awu.js";
+import { z } from "@bpinternal/zui";
+//#region src/typings-formatter.ts
+/**
+* A minimal, dependency-free formatter for the TypeScript typings generated by
+* llmz (typings.ts, objects.ts, hoist.ts). It supports only the small grammar
+* those generators emit — type expressions, `declare const` / `declare function`
+* declarations, `type` aliases and `export namespace` blocks — and produces
+* prettier-like output: 80 columns, 2-space indent, no semicolons in broken
+* objects, hugged single-object function params, unions wrapped with leading `|`.
+*
+* If the input cannot be tokenized or has unbalanced brackets, it is returned
+* unchanged.
+*/
+const WIDTH = 80;
+const INDENT = "  ";
+const isGroup = (n) => n.kind === "group";
+const isPunct = (n, text) => !isGroup(n) && n.kind === "punct" && n.text === text;
+const WORD_CHAR = /[A-Za-z0-9_$.]/;
+function tokenize(src) {
+	const toks = [];
+	let i = 0;
+	let nl = 0;
+	const len = src.length;
+	while (i < len) {
+		const c = src[i];
+		if (c === "\n") {
+			nl++;
+			i++;
+			continue;
+		}
+		if (c === " " || c === "	" || c === "\r") {
+			i++;
+			continue;
+		}
+		if (c === "/" && src[i + 1] === "*") {
+			const end = src.indexOf("*/", i + 2);
+			if (end === -1) throw new Error("unterminated block comment");
+			toks.push({
+				kind: "block-comment",
+				text: src.slice(i, end + 2),
+				nl
+			});
+			nl = 0;
+			i = end + 2;
+			continue;
+		}
+		if (c === "/" && src[i + 1] === "/") {
+			let end = src.indexOf("\n", i);
+			if (end === -1) end = len;
+			toks.push({
+				kind: "line-comment",
+				text: src.slice(i, end).trimEnd(),
+				nl
+			});
+			nl = 0;
+			i = end;
+			continue;
+		}
+		if (c === "'" || c === "\"" || c === "`") {
+			let j = i + 1;
+			while (j < len && src[j] !== c) j += src[j] === "\\" ? 2 : 1;
+			if (j >= len) throw new Error("unterminated string");
+			toks.push({
+				kind: "string",
+				text: src.slice(i, j + 1),
+				nl
+			});
+			nl = 0;
+			i = j + 1;
+			continue;
+		}
+		if (c === "=" && src[i + 1] === ">") {
+			toks.push({
+				kind: "punct",
+				text: "=>",
+				nl
+			});
+			nl = 0;
+			i += 2;
+			continue;
+		}
+		if (WORD_CHAR.test(c) || c === "-" && /\d/.test(src[i + 1] ?? "")) {
+			let j = i + 1;
+			while (j < len && WORD_CHAR.test(src[j])) j++;
+			toks.push({
+				kind: "word",
+				text: src.slice(i, j),
+				nl
+			});
+			nl = 0;
+			i = j;
+			continue;
+		}
+		toks.push({
+			kind: "punct",
+			text: c,
+			nl
+		});
+		nl = 0;
+		i++;
+	}
+	return toks;
+}
+const CLOSER = {
+	"{": "}",
+	"(": ")",
+	"[": "]",
+	"<": ">"
+};
+function parse(toks) {
+	const root = [];
+	const stack = [];
+	const siblings = () => stack.length ? stack[stack.length - 1].children : root;
+	for (const t of toks) {
+		if (t.kind === "punct" && (t.text === "{" || t.text === "(" || t.text === "[")) {
+			const g = {
+				kind: "group",
+				open: t.text,
+				close: CLOSER[t.text],
+				children: [],
+				nl: t.nl
+			};
+			siblings().push(g);
+			stack.push(g);
+			continue;
+		}
+		if (t.kind === "punct" && t.text === "<") {
+			const prev = siblings()[siblings().length - 1];
+			if (prev && !isGroup(prev) && prev.kind === "word") {
+				const g = {
+					kind: "group",
+					open: "<",
+					close: ">",
+					children: [],
+					nl: t.nl
+				};
+				siblings().push(g);
+				stack.push(g);
+				continue;
+			}
+			siblings().push(t);
+			continue;
+		}
+		if (t.kind === "punct" && (t.text === "}" || t.text === ")" || t.text === "]" || t.text === ">")) {
+			const g = stack[stack.length - 1];
+			if (t.text === ">" && (!g || g.open !== "<")) {
+				siblings().push(t);
+				continue;
+			}
+			if (!g || g.close !== t.text) throw new Error("unbalanced brackets");
+			stack.pop();
+			continue;
+		}
+		siblings().push(t);
+	}
+	if (stack.length) throw new Error("unbalanced brackets");
+	return root;
+}
+/**
+* Cleans up generator artifacts: trailing `,`/`;` inside groups, and redundant
+* parens in value position like `[key: (string)]: ({ ... } | undefined)`.
+*/
+function normalize(nodes) {
+	for (let i = 0; i < nodes.length; i++) {
+		const n = nodes[i];
+		if (!isGroup(n)) {
+			const key = n.kind === "string" && /^["']([A-Za-z_$][A-Za-z0-9_$]*)["']$/.exec(n.text);
+			const next = nodes[i + 1];
+			if (key && next && isPunct(next, ":")) nodes[i] = {
+				kind: "word",
+				text: key[1],
+				nl: n.nl
+			};
+			continue;
+		}
+		normalize(n.children);
+		while (n.children.length && (isPunct(n.children[n.children.length - 1], ",") || isPunct(n.children[n.children.length - 1], ";"))) n.children.pop();
+		const prev = nodes[i - 1];
+		const next = nodes[i + 1];
+		const wrapsWholeValue = next === void 0 || isPunct(next, ";") || isPunct(next, ",");
+		const isFunctionType = n.children.some((c) => isPunct(c, "=>"));
+		if (n.open === "(" && n.children.length > 0 && prev && isPunct(prev, ":") && wrapsWholeValue && !isFunctionType) {
+			n.children[0].nl = n.nl;
+			nodes.splice(i, 1, ...n.children);
+			i--;
+		}
+	}
+}
+function isMemberEnd(n) {
+	if (isGroup(n)) return true;
+	return n.kind === "word" || n.kind === "string" || n.kind === "block-comment" || n.kind === "line-comment" || n.text === "?";
+}
+function isMemberStart(n) {
+	if (isGroup(n)) return false;
+	return n.kind === "word" || n.kind === "string" || n.kind === "block-comment" || n.kind === "line-comment";
+}
+/**
+* Splits a flat node sequence into members: on top-level `;`, on top-level `,`
+* (when enabled), after line comments, and at "safe" newlines — a newline
+* between a token that can end a member and one that can start the next one.
+* Newlines elsewhere (e.g. the generator's stray newlines around descriptions)
+* are ignored.
+*/
+function splitMembers(nodes, splitOnComma) {
+	const members = [];
+	let cur = [];
+	let hasSeparators = false;
+	let usedComma = false;
+	const push = () => {
+		if (cur.length) members.push(cur);
+		cur = [];
+	};
+	for (const n of nodes) {
+		if (isPunct(n, ";") || splitOnComma && isPunct(n, ",")) {
+			hasSeparators = true;
+			usedComma ||= n.text === ",";
+			push();
+			continue;
+		}
+		const isTrailingLineComment = !isGroup(n) && n.kind === "line-comment" && n.nl === 0;
+		if (isTrailingLineComment && !cur.length && members.length) {
+			members[members.length - 1].push(n);
+			continue;
+		}
+		if (cur.length) {
+			const prev = cur[cur.length - 1];
+			if (!isGroup(prev) && prev.kind === "line-comment" || n.nl > 0 && !isTrailingLineComment && isMemberEnd(prev) && isMemberStart(n)) push();
+		}
+		cur.push(n);
+	}
+	push();
+	for (let i = members.length - 2; i >= 0; i--) if (members[i].every((n) => !isGroup(n) && n.kind === "block-comment")) {
+		members[i + 1].unshift(...members[i]);
+		members.splice(i, 1);
+	}
+	return {
+		members,
+		hasSeparators,
+		usedComma
+	};
+}
+function hasMultilineComment(nodes) {
+	return nodes.some((n) => !isGroup(n) && n.kind === "block-comment" && n.text.includes("\n"));
+}
+function hasLineComment(nodes) {
+	return nodes.some((n) => !isGroup(n) && n.kind === "line-comment");
+}
+/** Whether a group can never be rendered on a single line. */
+function mustBreak(g) {
+	if (hasLineComment(g.children) || hasMultilineComment(g.children)) return true;
+	const { members, hasSeparators } = splitMembers(g.children, true);
+	if (members.length > 1 && !hasSeparators) return true;
+	if ((g.open === "{" || g.open === "(") && members.some((m) => !isGroup(m[0]) && m[0].kind === "block-comment")) return true;
+	return g.children.some((c) => isGroup(c) && mustBreak(c));
+}
+function needSpace(a, b) {
+	if (!a) return false;
+	if (a.kind === "open" && b.kind === "close") return false;
+	if (b.kind === "punct" && (b.text === "," || b.text === ";" || b.text === ":" || b.text === "?")) return false;
+	if (b.kind === "close") return b.text === "}";
+	if (a.kind === "open") return a.text === "{";
+	if (b.kind === "open") {
+		if (b.text === "(" || b.text === "[") return !(a.kind === "word" || a.kind === "string" || a.kind === "close");
+		if (b.text === "<") return false;
+		return true;
+	}
+	return true;
+}
+function flatAtoms(nodes) {
+	const out = [];
+	for (const n of nodes) if (isGroup(n)) {
+		out.push({
+			kind: "open",
+			text: n.open
+		});
+		out.push(...flatAtoms(n.children));
+		out.push({
+			kind: "close",
+			text: n.close
+		});
+	} else out.push({
+		kind: n.kind,
+		text: n.text
+	});
+	return out;
+}
+function joinAtoms(atoms) {
+	let s = "";
+	let prev = null;
+	for (const a of atoms) {
+		if (needSpace(prev, a)) s += " ";
+		s += a.text;
+		prev = a;
+	}
+	return s;
+}
+const canFlatten = (nodes) => !hasLineComment(nodes) && !hasMultilineComment(nodes) && !nodes.some((n) => isGroup(n) && mustBreak(n));
+var Printer = class {
+	_lines = [];
+	_cur = "";
+	_prev = null;
+	atom(a) {
+		if (this._prev && this._cur !== "" && needSpace(this._prev, a)) this._cur += " ";
+		this._cur += a.text;
+		this._prev = a;
+	}
+	flat(nodes) {
+		for (const a of flatAtoms(nodes)) this.atom(a);
+	}
+	newline(level) {
+		this._lines.push(this._cur);
+		this._cur = INDENT.repeat(level);
+		this._prev = null;
+	}
+	blankLine(level) {
+		this._lines.push(this._cur);
+		this._lines.push("");
+		this._cur = INDENT.repeat(level);
+		this._prev = null;
+	}
+	get column() {
+		return this._cur.length;
+	}
+	get lineIsEmpty() {
+		return this._cur.trim() === "";
+	}
+	comment(text, level) {
+		const lines = text.split("\n").map((l) => l.trim());
+		for (let i = 0; i < lines.length; i++) {
+			if (i > 0) {
+				this.newline(level);
+				this._cur += lines[i].startsWith("*") ? " " : "";
+				this._cur += lines[i];
+			} else this.atom({
+				kind: "block-comment",
+				text: lines[i]
+			});
+			this._prev = {
+				kind: "block-comment",
+				text: lines[i]
+			};
+		}
+	}
+	toString() {
+		this._lines.push(this._cur);
+		const out = this._lines.map((l) => l.trim() === "" ? "" : l).join("\n").replace(/\n{3,}/g, "\n\n");
+		this._lines.pop();
+		return out.trim();
+	}
+};
+function flatWidth(nodes) {
+	if (!canFlatten(nodes)) return null;
+	return joinAtoms(flatAtoms(nodes)).length;
+}
+function fitsFlat(p, nodes) {
+	const width = flatWidth(nodes);
+	return width !== null && p.column + width + 1 <= WIDTH;
+}
+/**
+* Emits nodes left to right, breaking groups in place when they don't fit.
+* `tailWidth` is the flat width of whatever the caller will emit right after
+* these nodes on the same line (e.g. `): unknown` after hugged params).
+*/
+function walk(p, nodes, level, tailWidth = 0) {
+	for (let i = 0; i < nodes.length; i++) {
+		const n = nodes[i];
+		if (isGroup(n)) {
+			const own = mustBreak(n) ? null : flatWidth([n]);
+			let restNodes = nodes.slice(i + 1);
+			const lineCommentIdx = restNodes.findIndex((x) => !isGroup(x) && x.kind === "line-comment");
+			if (lineCommentIdx !== -1) restNodes = restNodes.slice(0, lineCommentIdx);
+			const rest = flatWidth(restNodes);
+			const after = rest === null ? 0 : rest + tailWidth;
+			if (own !== null && p.column + 1 + own + after <= WIDTH) p.flat([n]);
+			else breakGroup(p, n, level, after);
+			continue;
+		}
+		if (n.kind === "block-comment" && n.text.includes("\n")) {
+			if (!p.lineIsEmpty) p.newline(level);
+			p.comment(n.text, level);
+			p.newline(level);
+			continue;
+		}
+		if (n.kind === "line-comment") {
+			p.atom({
+				kind: "line-comment",
+				text: n.text
+			});
+			continue;
+		}
+		p.atom({
+			kind: n.kind,
+			text: n.text
+		});
+	}
+}
+function breakGroup(p, g, level, tailWidth = 0) {
+	if (g.open === "<") {
+		p.atom({
+			kind: "open",
+			text: "<"
+		});
+		walk(p, g.children, level, tailWidth + 1);
+		p.atom({
+			kind: "close",
+			text: ">"
+		});
+		return;
+	}
+	const { members, usedComma } = splitMembers(g.children, true);
+	const hasLeadingComment = members.some((m) => !isGroup(m[0]) && m[0].kind === "block-comment");
+	const single = members.length === 1 ? members[0] : null;
+	const endsInObject = !!single && isGroup(single[single.length - 1]) && single[single.length - 1].open === "{";
+	const hasUnion = !!single && single.some((n) => isPunct(n, "|"));
+	if (g.open === "(" && endsInObject && !hasUnion && !hasLeadingComment) {
+		p.atom({
+			kind: "open",
+			text: "("
+		});
+		walk(p, g.children, level, tailWidth + 1);
+		p.atom({
+			kind: "close",
+			text: ")"
+		});
+		return;
+	}
+	const separator = g.open === "(" || g.open === "[" ? "," : usedComma ? "," : null;
+	const trailingSeparator = g.open === "(" || g.open === "[";
+	p.atom({
+		kind: "open",
+		text: g.open
+	});
+	for (let i = 0; i < members.length; i++) {
+		p.newline(level + 1);
+		renderMember(p, members[i], level + 1);
+		if (separator && (trailingSeparator || i < members.length - 1)) p.atom({
+			kind: "punct",
+			text: separator
+		});
+	}
+	p.newline(level);
+	p.atom({
+		kind: "close",
+		text: g.close
+	});
+}
+/** Renders one member (or statement body): leading comments, then flat / union-break / walk. */
+function renderMember(p, nodes, level) {
+	let rest = nodes;
+	while (rest.length && !isGroup(rest[0]) && rest[0].kind === "block-comment") {
+		const c = rest[0];
+		p.comment(c.text, level);
+		rest = rest.slice(1);
+		if (rest.length) p.newline(level);
+	}
+	if (!rest.length) return;
+	if (fitsFlat(p, rest)) {
+		p.flat(rest);
+		return;
+	}
+	const pipeIdx = rest.findIndex((n) => isPunct(n, "|"));
+	const parenIdx = rest.findIndex((n) => isGroup(n) && n.open === "(");
+	if (pipeIdx !== -1 && (parenIdx === -1 || pipeIdx < parenIdx)) {
+		let colonIdx = -1;
+		for (let i = 0; i < pipeIdx; i++) if (isPunct(rest[i], ":") || isPunct(rest[i], "=")) colonIdx = i;
+		const prefix = rest.slice(0, colonIdx + 1);
+		const tail = rest.slice(colonIdx + 1);
+		if (!prefix.length || fitsFlat(p, prefix)) {
+			p.flat(prefix);
+			const options = [];
+			let cur = [];
+			for (const n of tail) if (isPunct(n, "|")) {
+				options.push(cur);
+				cur = [];
+			} else cur.push(n);
+			options.push(cur);
+			const optionLevel = prefix.length ? level + 1 : level;
+			let first = true;
+			for (const option of options) {
+				if (!option.length) continue;
+				if (!first || prefix.length) p.newline(optionLevel);
+				first = false;
+				p.atom({
+					kind: "punct",
+					text: "|"
+				});
+				walk(p, option, optionLevel + 1);
+			}
+			return;
+		}
+	}
+	const eqIdx = rest.findIndex((n) => isPunct(n, "="));
+	if (eqIdx !== -1) {
+		const prefix = rest.slice(0, eqIdx + 1);
+		if (fitsFlat(p, prefix)) {
+			p.flat(prefix);
+			walk(p, rest.slice(eqIdx + 1), level);
+			return;
+		}
+	}
+	walk(p, rest, level);
+}
+function renderStatements(p, nodes, level) {
+	const { members: statements } = splitMembers(nodes, false);
+	for (let i = 0; i < statements.length; i++) {
+		const stmt = statements[i];
+		if (i > 0) {
+			if ((stmt[0].nl ?? 0) >= 2) p.blankLine(level);
+			else p.newline(level);
+		}
+		renderStatement(p, stmt, level);
+	}
+}
+function renderStatement(p, stmt, level) {
+	while (stmt.length && !isGroup(stmt[0]) && stmt[0].kind === "block-comment") {
+		p.comment(stmt[0].text, level);
+		stmt = stmt.slice(1);
+		if (stmt.length) p.newline(level);
+	}
+	if (!stmt.length) return;
+	const nsIdx = stmt.findIndex((n) => !isGroup(n) && n.kind === "word" && (n.text === "namespace" || n.text === "module"));
+	const bodyIdx = stmt.findIndex((n) => isGroup(n) && n.open === "{");
+	if (nsIdx !== -1 && bodyIdx > nsIdx) {
+		const body = stmt[bodyIdx];
+		p.flat(stmt.slice(0, bodyIdx));
+		p.atom({
+			kind: "open",
+			text: "{"
+		});
+		if (body.children.length) {
+			p.newline(level + 1);
+			renderStatements(p, body.children, level + 1);
+			p.newline(level);
+		}
+		p.atom({
+			kind: "close",
+			text: "}"
+		});
+		walk(p, stmt.slice(bodyIdx + 1), level);
+		return;
+	}
+	renderMember(p, stmt, level);
+}
+/** Formats typings, throwing on input it cannot parse (unbalanced brackets, etc.) */
+function formatTypingsUnsafe(typings) {
+	const tokens = tokenize(typings);
+	if (!tokens.length) return "";
+	const nodes = parse(tokens);
+	normalize(nodes);
+	const printer = new Printer();
+	renderStatements(printer, nodes, 0);
+	return printer.toString();
+}
+//#endregion
+//#region src/formatting.ts
+async function formatTypings(typings, options) {
+	try {
+		return formatTypingsUnsafe(typings);
+	} catch (err) {
+		if ((options === null || options === void 0 ? void 0 : options.throwOnError) ?? true) throw new CodeFormattingError(err instanceof Error ? err.message : (err === null || err === void 0 ? void 0 : err.toString()) ?? "Unknown Error", typings);
+		return typings;
+	}
+}
+//#endregion
+//#region src/typings.ts
+var typings_exports = /* @__PURE__ */ __exportAll({ getTypings: () => getTypings });
+const Primitives = [
+	"string",
+	"number",
+	"boolean",
+	"unknown",
+	"void",
+	"any",
+	"null",
+	"undefined",
+	"never",
+	"bigint",
+	"symbol",
+	"object"
+];
+const LARGE_DECLARATION_LINES = 5;
+const isPrimitive = (type) => Primitives.includes(type);
+const isArrayOfPrimitives = (type) => Primitives.map((p) => `${p}[]`).includes(type);
+const stripSpaces = (typings) => typings.replace(/ +/g, " ").trim();
+var KeyValue = class {
+	key;
+	value;
+	constructor(key, value) {
+		this.key = key;
+		this.value = value;
+	}
+};
+var FnParameters = class {
+	schema;
+	constructor(schema) {
+		this.schema = schema;
+	}
+};
+var FnReturn = class {
+	schema;
+	constructor(schema) {
+		this.schema = schema;
+	}
+};
+var Declaration = class {
+	schema;
+	identifier;
+	constructor(schema, identifier) {
+		this.schema = schema;
+		this.identifier = identifier;
+	}
+};
+async function getTypings(schema, options) {
+	options ??= {};
+	options.declaration ??= false;
+	let wrappedSchema = schema;
+	if ((options === null || options === void 0 ? void 0 : options.declaration) && z.is.zuiType(schema)) {
+		const title = "title" in schema.ui ? schema.ui.title : null;
+		if (!title) throw new Error("Only schemas with \"title\" Zui property can be declared.");
+		wrappedSchema = new Declaration(schema, title);
+	}
+	let dts = await sUnwrapZodRecursive(wrappedSchema, { ...options });
+	dts = await formatTypings(dts, { throwOnError: false });
+	return dts;
+}
+async function sUnwrapZodRecursive(schema, options) {
+	return sUnwrapZod(schema, options);
+}
+async function sUnwrapZod(schema, options) {
+	const newOptions = {
+		...options,
+		declaration: false,
+		parent: schema
+	};
+	if (schema instanceof Declaration) {
+		const description = getMultilineComment(schema.schema.description);
+		const typings = await sUnwrapZodRecursive(schema.schema.describe(""), {
+			...newOptions,
+			declaration: true
+		});
+		const closingTag = typings.split("\n").length >= LARGE_DECLARATION_LINES ? `// end of ${schema.identifier}` : "";
+		if (z.is.zuiFunction(schema.schema)) return stripSpaces(`${description}
+declare function ${schema.identifier}${typings};${closingTag}`);
+		return stripSpaces(`${description}
+declare const ${schema.identifier}: ${typings};${closingTag}`);
+	}
+	if (schema instanceof KeyValue) {
+		if (z.is.zuiOptional(schema.value) || z.is.zuiDefault(schema.value)) {
+			let innerType = schema.value._def.innerType;
+			if (z.is.zuiType(innerType) && !innerType.description && schema.value.description) innerType = innerType === null || innerType === void 0 ? void 0 : innerType.describe(schema.value.description);
+			const optionalToken = schema.key.endsWith("?") ? "" : "?";
+			return sUnwrapZodRecursive(new KeyValue(schema.key + optionalToken, innerType), newOptions);
+		}
+		const description = getMultilineComment(schema.value._def.description || schema.value.description);
+		const delimiter = (description === null || description === void 0 ? void 0 : description.trim().length) > 0 ? "\n" : "";
+		const withoutDesc = schema.value.describe("");
+		return `${delimiter}${description}${delimiter}${schema.key}: ${await sUnwrapZodRecursive(withoutDesc, newOptions)}${delimiter}`;
+	}
+	if (schema instanceof FnParameters) {
+		if (z.is.zuiTuple(schema.schema)) {
+			let args = "";
+			for (let i = 0; i < schema.schema.items.length; i++) {
+				var _schema$schema$items$;
+				const argName = ((_schema$schema$items$ = schema.schema.items[i]) === null || _schema$schema$items$ === void 0 || (_schema$schema$items$ = _schema$schema$items$.ui) === null || _schema$schema$items$ === void 0 ? void 0 : _schema$schema$items$.title) ?? `arg${i}`;
+				const item = schema.schema.items[i];
+				args += `${await sUnwrapZodRecursive(new KeyValue(toPropertyKey(argName), item), newOptions)}, `;
+			}
+			return args;
+		}
+		const isLiteral = z.is.zuiLiteral(schema.schema.naked());
+		const typings = (await sUnwrapZodRecursive(schema.schema, newOptions)).trim();
+		if (typings.startsWith("{") && typings.endsWith("}") || typings.startsWith("[") && typings.endsWith("]") || typings.startsWith("(") && typings.endsWith(")") || typings.startsWith("Array<") && typings.endsWith(">") || typings.startsWith("Record<") && typings.endsWith(">") || isArrayOfPrimitives(typings) || isLiteral) return `args: ${typings}`;
+		else return typings;
+	}
+	if (schema instanceof FnReturn) {
+		if (z.is.zuiOptional(schema.schema)) return `${await sUnwrapZodRecursive(schema.schema.unwrap(), newOptions)} | undefined`;
+		return sUnwrapZodRecursive(schema.schema, newOptions);
+	}
+	if (schema === null) return "unknown";
+	if (z.is.zuiDefault(schema)) return sUnwrapZodRecursive(schema._def.innerType, options);
+	if (z.is.zuiVoid(schema)) return "void";
+	if (z.is.zuiUnknown(schema)) return "unknown";
+	if (z.is.zuiAny(schema)) return "any";
+	if (z.is.zuiPromise(schema)) return `Promise<${await sUnwrapZodRecursive(schema.unwrap(), newOptions)}>`;
+	if (z.is.zuiFunction(schema)) {
+		const description = getMultilineComment(schema._def.description);
+		const input = await sUnwrapZodRecursive(new FnParameters(schema._def.args), newOptions);
+		const output = await sUnwrapZodRecursive(new FnReturn(schema._def.returns), newOptions);
+		if (options === null || options === void 0 ? void 0 : options.declaration) return `${description}
+(${input}): ${output}`;
+		return `${description}
+(${input}) => ${output}`;
+	}
+	if (z.is.zuiArray(schema)) {
+		const item = await sUnwrapZodRecursive(schema._def.type, newOptions);
+		if (isPrimitive(item)) return `${item}[]`;
+		return `Array<${item}>`;
+	}
+	if (z.is.zuiEnum(schema)) return schema._def.values.map(escapeString).join(" | ");
+	if (z.is.zuiTuple(schema)) {
+		if (schema.items.length === 0) return "[]";
+		return `[${(await Promise.all(schema.items.map((i) => sUnwrapZodRecursive(i, newOptions)))).join(", ")}]`;
+	}
+	if (z.is.zuiNullable(schema)) return `${await sUnwrapZodRecursive(schema.unwrap(), options)} | null`;
+	if (z.is.zuiOptional(schema)) {
+		if ((options === null || options === void 0 ? void 0 : options.declaration) || z.is.zuiType(options === null || options === void 0 ? void 0 : options.parent) && options.parent.typeName === "ZodRecord") return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)} | undefined`;
+		const optionalToken = options.parent instanceof KeyValue ? "| undefined" : "";
+		return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)}${optionalToken}`;
+	}
+	if (z.is.zuiObject(schema)) return `{ ${(await Promise.all(Object.entries(schema.shape).map(async ([key, value]) => {
+		if (z.is.zuiType(value)) return sUnwrapZodRecursive(new KeyValue(toPropertyKey(key), value), newOptions);
+		return `${key}: unknown`;
+	}))).join("; ")} }`;
+	if (z.is.zuiString(schema)) return `${getMultilineComment(schema._def.description)} string`.trim();
+	if (z.is.zuiUnion(schema)) return `${getMultilineComment(schema._def.description)}
+${(await Promise.all(schema.options.map(async (option) => {
+		return sUnwrapZodRecursive(option, newOptions);
+	}))).join(" | ")}`;
+	if (z.is.zuiLiteral(schema)) return `${getMultilineComment(schema._def.description)}
+${typeof schema.value === "string" ? escapeString(schema.value) : String(schema.value)}`.trim();
+	if (z.is.zuiNumber(schema)) return `${getMultilineComment(schema._def.description)} number`.trim();
+	if (z.is.zuiBoolean(schema)) return `${getMultilineComment(schema._def.description)} boolean`.trim();
+	if (z.is.zuiCatch(schema)) return sUnwrapZodRecursive(schema.removeCatch(), newOptions);
+	if (z.is.zuiLazy(schema)) return sUnwrapZodRecursive(schema._def.getter(), newOptions);
+	if (z.is.zuiRecord(schema)) return `${getMultilineComment(schema._def.description)} { [key: (${await sUnwrapZodRecursive(schema._def.keyType, newOptions)})]: (${await sUnwrapZodRecursive(schema._def.valueType, newOptions)}) }`;
+	try {
+		let typings = schema === null || schema === void 0 ? void 0 : schema.toTypescriptType({ treatDefaultAsOptional: true });
+		typings ??= "unknown";
+		return stripSpaces(typings);
+	} catch (error) {
+		console.error("Error in sUnwrapZod", {
+			error,
+			schema,
+			parent: options === null || options === void 0 ? void 0 : options.parent
+		});
+		return "unknown";
+	}
+}
+//#endregion
+export { isPunct as a, isGroup as i, typings_exports as n, parse as o, formatTypings as r, tokenize as s, getTypings as t };