llmz 0.6.0 → 0.6.2

package/dist/chunk-HMMM32RG.cjs

@@ -1,792 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;
-
-var _chunkPK72FAKDcjs = require('./chunk-PK72FAKD.cjs');
-
-
-
-
-var _chunkGOWPACSKcjs = require('./chunk-GOWPACSK.cjs');
-
-// src/typings.ts
-var _zui = require('@bpinternal/zui');
-
-// src/typings-formatter.ts
-var WIDTH = 80;
-var INDENT = "  ";
-var isGroup = (n) => n.kind === "group";
-var isPunct = (n, text) => !isGroup(n) && n.kind === "punct" && n.text === text;
-var 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(_nullishCoalesce(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;
-}
-var 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;
-}
-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 next2 = nodes[i + 1];
-      if (key && next2 && isPunct(next2, ":")) {
-        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";
-}
-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];
-      const prevIsLineComment = !isGroup(prev) && prev.kind === "line-comment";
-      if (prevIsLineComment || n.nl > 0 && !isTrailingLineComment && isMemberEnd(prev) && isMemberStart(n)) {
-        push();
-      }
-    }
-    cur.push(n);
-  }
-  push();
-  for (let i = members.length - 2; i >= 0; i--) {
-    const onlyComments = members[i].every((n) => !isGroup(n) && n.kind === "block-comment");
-    if (onlyComments) {
-      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");
-}
-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;
-}
-var canFlatten = (nodes) => !hasLineComment(nodes) && !hasMultilineComment(nodes) && !nodes.some((n) => isGroup(n) && mustBreak(n));
-var Printer = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this); }
-  __init() {this._lines = []}
-  __init2() {this._cur = ""}
-  __init3() {this._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();
-  }
-}, _class);
-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;
-}
-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 });
-}
-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 ((_nullishCoalesce(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);
-}
-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();
-}
-
-// src/formatting.ts
-async function formatTypings(typings, options) {
-  try {
-    return formatTypingsUnsafe(typings);
-  } catch (err) {
-    if (_nullishCoalesce((options == null ? void 0 : options.throwOnError), () => ( true))) {
-      throw new (0, _chunkPK72FAKDcjs.CodeFormattingError)(err instanceof Error ? err.message : _nullishCoalesce((err == null ? void 0 : err.toString()), () => ( "Unknown Error")), typings);
-    }
-    return typings;
-  }
-}
-
-// src/typings.ts
-var Primitives = [
-  "string",
-  "number",
-  "boolean",
-  "unknown",
-  "void",
-  "any",
-  "null",
-  "undefined",
-  "never",
-  "bigint",
-  "symbol",
-  "object"
-];
-var LARGE_DECLARATION_LINES = 5;
-var isPrimitive = (type) => Primitives.includes(type);
-var isArrayOfPrimitives = (type) => Primitives.map((p) => `${p}[]`).includes(type);
-var stripSpaces = (typings) => typings.replace(/ +/g, " ").trim();
-var KeyValue = class {
-  constructor(key, value) {
-    this.key = key;
-    this.value = value;
-  }
-};
-var FnParameters = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-};
-var FnReturn = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-};
-var Declaration = class {
-  constructor(schema, identifier) {
-    this.schema = schema;
-    this.identifier = identifier;
-  }
-};
-async function getTypings(schema, options) {
-  options ??= {};
-  options.declaration ??= false;
-  let wrappedSchema = schema;
-  if ((options == null ? void 0 : options.declaration) && _zui.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) {
-  var _a, _b;
-  const newOptions = {
-    ...options,
-    declaration: false,
-    parent: schema
-  };
-  if (schema instanceof Declaration) {
-    const description = _chunkGOWPACSKcjs.getMultilineComment.call(void 0, schema.schema.description);
-    const withoutDesc = schema.schema.describe("");
-    const typings = await sUnwrapZodRecursive(withoutDesc, { ...newOptions, declaration: true });
-    const isLargeDeclaration = typings.split("\n").length >= LARGE_DECLARATION_LINES;
-    const closingTag = isLargeDeclaration ? `// end of ${schema.identifier}` : "";
-    if (_zui.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 (_zui.z.is.zuiOptional(schema.value) || _zui.z.is.zuiDefault(schema.value)) {
-      let innerType = schema.value._def.innerType;
-      if (_zui.z.is.zuiType(innerType) && !innerType.description && schema.value.description) {
-        innerType = innerType == null ? void 0 : innerType.describe(schema.value.description);
-      }
-      const optionalToken = schema.key.endsWith("?") ? "" : "?";
-      return sUnwrapZodRecursive(new KeyValue(schema.key + optionalToken, innerType), newOptions);
-    }
-    const description = _chunkGOWPACSKcjs.getMultilineComment.call(void 0, schema.value._def.description || schema.value.description);
-    const delimiter = (description == null ? 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 (_zui.z.is.zuiTuple(schema.schema)) {
-      let args = "";
-      for (let i = 0; i < schema.schema.items.length; i++) {
-        const argName = _nullishCoalesce(((_b = (_a = schema.schema.items[i]) == null ? void 0 : _a.ui) == null ? void 0 : _b.title), () => ( `arg${i}`));
-        const item = schema.schema.items[i];
-        args += `${await sUnwrapZodRecursive(new KeyValue(_chunkGOWPACSKcjs.toPropertyKey.call(void 0, argName), item), newOptions)}, `;
-      }
-      return args;
-    }
-    const isLiteral = _zui.z.is.zuiLiteral(schema.schema.naked());
-    const typings = (await sUnwrapZodRecursive(schema.schema, newOptions)).trim();
-    const startsWithPairs = typings.startsWith("{") && typings.endsWith("}") || typings.startsWith("[") && typings.endsWith("]") || typings.startsWith("(") && typings.endsWith(")") || typings.startsWith("Array<") && typings.endsWith(">") || typings.startsWith("Record<") && typings.endsWith(">") || isArrayOfPrimitives(typings);
-    if (startsWithPairs || isLiteral) {
-      return `args: ${typings}`;
-    } else {
-      return typings;
-    }
-  }
-  if (schema instanceof FnReturn) {
-    if (_zui.z.is.zuiOptional(schema.schema)) {
-      return `${await sUnwrapZodRecursive(schema.schema.unwrap(), newOptions)} | undefined`;
-    }
-    return sUnwrapZodRecursive(schema.schema, newOptions);
-  }
-  if (schema === null) {
-    return "unknown";
-  }
-  schema;
-  if (_zui.z.is.zuiDefault(schema)) {
-    return sUnwrapZodRecursive(schema._def.innerType, options);
-  }
-  if (_zui.z.is.zuiVoid(schema)) {
-    return "void";
-  }
-  if (_zui.z.is.zuiUnknown(schema)) {
-    return "unknown";
-  }
-  if (_zui.z.is.zuiAny(schema)) {
-    return "any";
-  }
-  if (_zui.z.is.zuiPromise(schema)) {
-    return `Promise<${await sUnwrapZodRecursive(schema.unwrap(), newOptions)}>`;
-  }
-  if (_zui.z.is.zuiFunction(schema)) {
-    const description = _chunkGOWPACSKcjs.getMultilineComment.call(void 0, 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 ? void 0 : options.declaration) {
-      return `${description}
-(${input}): ${output}`;
-    }
-    return `${description}
-(${input}) => ${output}`;
-  }
-  if (_zui.z.is.zuiArray(schema)) {
-    const item = await sUnwrapZodRecursive(schema._def.type, newOptions);
-    if (isPrimitive(item)) {
-      return `${item}[]`;
-    }
-    return `Array<${item}>`;
-  }
-  if (_zui.z.is.zuiEnum(schema)) {
-    const values = schema._def.values.map(_chunkGOWPACSKcjs.escapeString);
-    return values.join(" | ");
-  }
-  if (_zui.z.is.zuiTuple(schema)) {
-    if (schema.items.length === 0) {
-      return "[]";
-    }
-    const items = await Promise.all(schema.items.map((i) => sUnwrapZodRecursive(i, newOptions)));
-    return `[${items.join(", ")}]`;
-  }
-  if (_zui.z.is.zuiNullable(schema)) {
-    return `${await sUnwrapZodRecursive(schema.unwrap(), options)} | null`;
-  }
-  if (_zui.z.is.zuiOptional(schema)) {
-    if ((options == null ? void 0 : options.declaration) || _zui.z.is.zuiType(options == null ? void 0 : options.parent) && options.parent.typeName === "ZodRecord") {
-      return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)} | undefined`;
-    }
-    const optionalToken = options.parent instanceof KeyValue ? "| undefined" : "";
-    const val = `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)}${optionalToken}`;
-    return val;
-  }
-  if (_zui.z.is.zuiObject(schema)) {
-    const props = await Promise.all(
-      Object.entries(schema.shape).map(async ([key, value]) => {
-        if (_zui.z.is.zuiType(value)) {
-          return sUnwrapZodRecursive(new KeyValue(_chunkGOWPACSKcjs.toPropertyKey.call(void 0, key), value), newOptions);
-        }
-        return `${key}: unknown`;
-      })
-    );
-    return `{ ${props.join("; ")} }`;
-  }
-  if (_zui.z.is.zuiString(schema)) {
-    const description = _chunkGOWPACSKcjs.getMultilineComment.call(void 0, schema._def.description);
-    return `${description} string`.trim();
-  }
-  if (_zui.z.is.zuiUnion(schema)) {
-    const description = _chunkGOWPACSKcjs.getMultilineComment.call(void 0, schema._def.description);
-    const options2 = await Promise.all(
-      schema.options.map(async (option) => {
-        return sUnwrapZodRecursive(option, newOptions);
-      })
-    );
-    return `${description}
-${options2.join(" | ")}`;
-  }
-  if (_zui.z.is.zuiLiteral(schema)) {
-    const description = _chunkGOWPACSKcjs.getMultilineComment.call(void 0, schema._def.description);
-    return `${description}
-${typeof schema.value === "string" ? _chunkGOWPACSKcjs.escapeString.call(void 0, schema.value) : String(schema.value)}`.trim();
-  }
-  if (_zui.z.is.zuiNumber(schema)) {
-    const description = _chunkGOWPACSKcjs.getMultilineComment.call(void 0, schema._def.description);
-    return `${description} number`.trim();
-  }
-  if (_zui.z.is.zuiBoolean(schema)) {
-    const description = _chunkGOWPACSKcjs.getMultilineComment.call(void 0, schema._def.description);
-    return `${description} boolean`.trim();
-  }
-  if (_zui.z.is.zuiCatch(schema)) {
-    return sUnwrapZodRecursive(schema.removeCatch(), newOptions);
-  }
-  if (_zui.z.is.zuiLazy(schema)) {
-    return sUnwrapZodRecursive(schema._def.getter(), newOptions);
-  }
-  if (_zui.z.is.zuiRecord(schema)) {
-    const description = _chunkGOWPACSKcjs.getMultilineComment.call(void 0, schema._def.description);
-    const keyType = await sUnwrapZodRecursive(schema._def.keyType, newOptions);
-    const valueType = await sUnwrapZodRecursive(schema._def.valueType, newOptions);
-    return `${description} { [key: (${keyType})]: (${valueType}) }`;
-  }
-  try {
-    let typings = schema == null ? void 0 : schema.toTypescriptType({ treatDefaultAsOptional: true });
-    typings ??= "unknown";
-    return stripSpaces(typings);
-  } catch (error) {
-    console.error("Error in sUnwrapZod", { error, schema, parent: options == null ? void 0 : options.parent });
-    return "unknown";
-  }
-}
-
-
-
-
-
-
-
-
-exports.isGroup = isGroup; exports.isPunct = isPunct; exports.tokenize = tokenize; exports.parse = parse; exports.formatTypings = formatTypings; exports.getTypings = getTypings;