@polagram/core 0.0.2

package/dist/polagram-core.js

@@ -0,0 +1,3653 @@
+var Tt = Object.defineProperty;
+var Zt = (e, t, n) => t in e ? Tt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var be = (e, t, n) => Zt(e, typeof t != "symbol" ? t + "" : t, n);
+class It {
+  constructor(t) {
+    this.input = t, this.readChar();
+  }
+  position = 0;
+  readPosition = 0;
+  ch = "";
+  line = 1;
+  column = 0;
+  getInput() {
+    return this.input;
+  }
+  readChar() {
+    this.readPosition >= this.input.length ? this.ch = "" : this.ch = this.input[this.readPosition], this.position = this.readPosition, this.readPosition += 1, this.column += 1, this.ch === `
+` && (this.line += 1, this.column = 0);
+  }
+  peekChar() {
+    return this.readPosition >= this.input.length ? "" : this.input[this.readPosition];
+  }
+  skipWhitespace() {
+    for (; this.ch === " " || this.ch === "	" || this.ch === "\r"; )
+      this.readChar();
+  }
+  readWhile(t) {
+    const n = this.position;
+    for (; t(this.ch); )
+      this.readChar();
+    return this.input.slice(n, this.position);
+  }
+  isLetter(t) {
+    return "a" <= t && t <= "z" || "A" <= t && t <= "Z" || t === "_" ? !0 : t.charCodeAt(0) > 127 ? !/[\s\d]/.test(t) : !1;
+  }
+  isDigit(t) {
+    return "0" <= t && t <= "9";
+  }
+}
+class Et extends It {
+  constructor(t) {
+    super(t);
+  }
+  nextToken() {
+    this.skipWhitespace();
+    const t = this.position, n = this.column;
+    let r;
+    switch (this.ch) {
+      case ":":
+        r = this.newToken("COLON", this.ch, t, n);
+        break;
+      case ",":
+        r = this.newToken("COMMA", this.ch, t, n);
+        break;
+      case "+":
+        r = this.newToken("PLUS", this.ch, t, n);
+        break;
+      case "-":
+        if (this.isArrowStart()) {
+          const i = this.readArrow();
+          return r = this.newToken("ARROW", i, t, n), r;
+        } else
+          r = this.newToken("MINUS", this.ch, t, n);
+        break;
+      case '"':
+        const o = this.readString();
+        return r = this.newToken("STRING", o, t, n), r;
+      case `
+`:
+        r = this.newToken("NEWLINE", this.ch, t, n);
+        break;
+      case "":
+        r = this.newToken("EOF", "", t, n);
+        break;
+      default:
+        if (this.isLetter(this.ch)) {
+          const i = this.readIdentifier(), s = this.lookupIdent(i);
+          return this.newToken(s, i, t, n);
+        } else if (this.isDigit(this.ch)) {
+          const i = this.readNumber();
+          return this.newToken("IDENTIFIER", i, t, n);
+        } else
+          r = this.newToken("UNKNOWN", this.ch, t, n);
+    }
+    return this.readChar(), r;
+  }
+  newToken(t, n, r, o) {
+    return {
+      type: t,
+      literal: n,
+      line: this.line,
+      column: o,
+      start: r,
+      // If the lexer position has advanced beyond the start (consumed tokens like String/Arrow), use that position.
+      // Otherwise (simple chars), assume length-based calculation.
+      end: this.position > r ? this.position : r + n.length
+    };
+  }
+  readIdentifier() {
+    const t = this.position;
+    for (; this.isLetter(this.ch) || this.isDigit(this.ch); )
+      this.readChar();
+    return this.input.slice(t, this.position);
+  }
+  readNumber() {
+    const t = this.position;
+    for (; this.isDigit(this.ch); )
+      this.readChar();
+    return this.input.slice(t, this.position);
+  }
+  readString() {
+    const t = this.position + 1;
+    for (this.readChar(); this.ch !== '"' && this.ch !== "" && this.ch !== `
+`; )
+      this.readChar();
+    const n = this.input.slice(t, this.position);
+    return this.ch, this.readChar(), n;
+  }
+  isArrowStart() {
+    if (this.ch !== "-") return !1;
+    const t = this.peekChar();
+    return t === ">" || t === "-" || t === ")" || t === "x";
+  }
+  readArrow() {
+    if (this.input.slice(this.position, this.position + 4) === "-->>")
+      return this.readMulti(4), "-->>";
+    const n = this.input.slice(this.position, this.position + 3);
+    if (n === "-->" || n === "--)" || n === "->>" || n === "--x")
+      return this.readMulti(3), n;
+    const r = this.input.slice(this.position, this.position + 2);
+    return r === "->" || r === "-)" || r === "-x" ? (this.readMulti(2), r) : "-";
+  }
+  readMulti(t) {
+    for (let n = 0; n < t; n++) this.readChar();
+  }
+  lookupIdent(t) {
+    return {
+      sequenceDiagram: "SEQUENCE_DIAGRAM",
+      participant: "PARTICIPANT",
+      actor: "ACTOR",
+      loop: "LOOP",
+      alt: "ALT",
+      opt: "OPT",
+      end: "END",
+      else: "ELSE",
+      note: "NOTE",
+      left: "LEFT",
+      right: "RIGHT",
+      over: "OVER",
+      of: "OF",
+      as: "AS",
+      title: "TITLE",
+      activate: "ACTIVATE",
+      deactivate: "DEACTIVATE",
+      box: "BOX"
+    }[t] || "IDENTIFIER";
+  }
+}
+class St {
+  constructor(t) {
+    this.lexer = t, this.advance(), this.advance();
+  }
+  currToken;
+  peekToken;
+  advance() {
+    this.currToken = this.peekToken, this.peekToken = this.lexer.nextToken();
+  }
+  curTokenIs(t) {
+    return this.currToken.type === t;
+  }
+  peekTokenIs(t) {
+    return this.peekToken.type === t;
+  }
+  expectPeek(t) {
+    return this.peekTokenIs(t) ? (this.advance(), !0) : !1;
+  }
+}
+const Ge = {
+  "->": { type: "sync", style: { line: "solid", head: "open" } },
+  "->>": { type: "sync", style: { line: "solid", head: "arrow" } },
+  "-->": { type: "reply", style: { line: "dotted", head: "open" } },
+  "-->>": { type: "reply", style: { line: "dotted", head: "arrow" } },
+  "-)": { type: "async", style: { line: "solid", head: "async" } },
+  "--)": { type: "async", style: { line: "dotted", head: "async" } },
+  "-x": { type: "destroy", style: { line: "solid", head: "cross" } },
+  "--x": { type: "destroy", style: { line: "dotted", head: "cross" } }
+}, Ot = Object.entries(Ge).reduce((e, [t, n]) => {
+  const r = JSON.stringify({ type: n.type, style: n.style });
+  return e[r] = t, e;
+}, {});
+function Pt(e, t) {
+  const n = JSON.stringify({ type: e, style: t });
+  return Ot[n] || "->>";
+}
+class Nt extends St {
+  currentGroup = null;
+  idCounters = {
+    evt: 0,
+    frag: 0,
+    br: 0,
+    note: 0,
+    group: 0
+  };
+  constructor(t) {
+    super(t);
+  }
+  parse() {
+    const t = {
+      kind: "root",
+      meta: { version: "1.0.0", source: "unknown" },
+      participants: [],
+      groups: [],
+      events: []
+    };
+    return t.events = this.parseBlock(t), t;
+  }
+  parseBlock(t, n = []) {
+    const r = [];
+    for (; this.currToken.type !== "EOF"; ) {
+      const o = this.currToken.type;
+      if (n.includes(o))
+        return r;
+      if (o === "NEWLINE") {
+        this.advance();
+        continue;
+      }
+      if (o === "SEQUENCE_DIAGRAM") {
+        t.meta.source = "mermaid", this.advance();
+        continue;
+      }
+      if (o === "TITLE") {
+        this.advance(), t.meta.title = this.readRestOfLine();
+        continue;
+      }
+      if (o === "BOX") {
+        const i = this.parseGroup(t);
+        r.push(...i);
+        continue;
+      }
+      if (o === "PARTICIPANT" || o === "ACTOR") {
+        this.parseParticipant(t);
+        continue;
+      }
+      if (o === "LOOP" || o === "ALT" || o === "OPT") {
+        r.push(this.parseFragment(t));
+        continue;
+      }
+      if (o === "NOTE") {
+        r.push(this.parseNote(t));
+        continue;
+      }
+      if (o === "ACTIVATE" || o === "DEACTIVATE") {
+        r.push(this.parseActivation(t));
+        continue;
+      }
+      if (this.isParticipantToken(this.currToken)) {
+        const i = this.parseMessage(t);
+        if (i) {
+          r.push(i);
+          continue;
+        }
+      }
+      this.advance();
+    }
+    return r;
+  }
+  isParticipantToken(t) {
+    return t.type === "IDENTIFIER" || t.type === "STRING";
+  }
+  parseGroup(t) {
+    this.advance();
+    const n = this.readRestOfLine().trim();
+    let r = n, o;
+    const i = n.split(/\s+/);
+    if (i.length > 0) {
+      const l = i[0];
+      (l.startsWith("#") || ["rgb", "rgba", "transparent", "aqua", "grey", "gray", "purple", "red", "blue", "green"].includes(l.toLowerCase())) && (o = l, r = i.slice(1).join(" "));
+    }
+    r || (r = `Group ${this.idCounters.group + 1}`);
+    const s = {
+      kind: "group",
+      id: this.generateId("group"),
+      name: r,
+      type: "box",
+      participantIds: [],
+      style: o ? { backgroundColor: o } : void 0
+    };
+    t.groups.push(s);
+    const a = this.currentGroup;
+    this.currentGroup = s;
+    const u = this.parseBlock(t, ["END"]);
+    return this.currentGroup = a, this.currToken.type === "END" && this.advance(), u;
+  }
+  parseFragment(t) {
+    const n = this.currToken.type;
+    let r = "loop";
+    n === "ALT" && (r = "alt"), n === "OPT" && (r = "opt"), this.advance();
+    const o = this.readRestOfLine(), i = [], s = this.parseBlock(t, ["END", "ELSE"]);
+    for (i.push({
+      id: this.generateId("br"),
+      condition: o,
+      events: s
+    }); this.currToken.type === "ELSE"; ) {
+      this.advance();
+      const a = this.readRestOfLine(), u = this.parseBlock(t, ["END", "ELSE"]);
+      i.push({
+        id: this.generateId("br"),
+        condition: a,
+        events: u
+      });
+    }
+    return this.currToken.type === "END" && this.advance(), {
+      kind: "fragment",
+      id: this.generateId("frag"),
+      operator: r,
+      branches: i
+    };
+  }
+  parseParticipant(t) {
+    const n = this.currToken.type === "ACTOR";
+    this.advance();
+    let r = "", o = "";
+    if (this.isParticipantToken(this.currToken) && (r = this.currToken.literal, o = r, this.advance()), this.currToken.type === "AS") {
+      this.advance();
+      const s = this.readRestOfLine().trim();
+      s && (o = s);
+    }
+    const i = t.participants.find((s) => s.id === r);
+    i ? (o !== r && (i.name = o), n && (i.type = "actor")) : t.participants.push({
+      id: r,
+      name: o,
+      type: n ? "actor" : "participant"
+    }), this.currentGroup && (this.currentGroup.participantIds.includes(r) || this.currentGroup.participantIds.push(r));
+  }
+  parseNote(t) {
+    this.advance();
+    let n = "over";
+    this.currToken.type === "LEFT" ? (n = "left", this.advance()) : this.currToken.type === "RIGHT" ? (n = "right", this.advance()) : this.currToken.type === "OVER" && (n = "over", this.advance()), this.currToken.type === "OF" && this.advance();
+    const r = [];
+    for (; this.isParticipantToken(this.currToken) && (r.push(this.currToken.literal), this.ensureParticipant(t, this.currToken.literal), this.advance(), this.currToken.type === "COMMA"); )
+      this.advance();
+    let o = "";
+    return this.currToken.type === "COLON" && (this.advance(), o = this.readRestOfLine()), {
+      kind: "note",
+      id: this.generateId("note"),
+      position: n,
+      participantIds: r,
+      text: o
+    };
+  }
+  parseActivation(t) {
+    const n = this.currToken.type === "ACTIVATE" ? "activate" : "deactivate";
+    this.advance();
+    let r = "";
+    return this.isParticipantToken(this.currToken) && (r = this.currToken.literal, this.ensureParticipant(t, r), this.advance()), {
+      kind: "activation",
+      participantId: r,
+      action: n
+    };
+  }
+  parseMessage(t) {
+    if (this.peekToken.type !== "ARROW")
+      return null;
+    const n = this.currToken.literal;
+    if (this.ensureParticipant(t, n), this.advance(), this.currToken.type !== "ARROW")
+      return null;
+    const r = this.currToken.literal;
+    this.advance();
+    let o = !1, i = !1;
+    if (this.currToken.type === "PLUS" && (o = !0, this.advance()), this.currToken.type === "MINUS" && (i = !0, this.advance()), !this.isParticipantToken(this.currToken)) return null;
+    const s = this.currToken.literal;
+    this.ensureParticipant(t, s), this.advance();
+    let a = "";
+    this.currToken.type === "COLON" && (this.advance(), a = this.readRestOfLine());
+    const { type: u, style: l } = this.resolveArrow(r);
+    return {
+      kind: "message",
+      id: this.generateId("evt"),
+      from: n,
+      to: s,
+      text: a,
+      type: u,
+      style: l,
+      lifecycle: o || i ? { activateTarget: o, deactivateSource: i } : void 0
+    };
+  }
+  resolveArrow(t) {
+    const n = Ge[t];
+    return n || { type: "sync", style: { line: "solid", head: "arrow" } };
+  }
+  generateId(t) {
+    return this.idCounters[t]++, `${t}_${this.idCounters[t]}`;
+  }
+  readRestOfLine() {
+    if (this.currToken.type === "NEWLINE" || this.currToken.type === "EOF")
+      return "";
+    const t = this.currToken.start;
+    let n = this.currToken.end;
+    for (; this.currToken.type !== "NEWLINE" && this.currToken.type !== "EOF"; )
+      n = this.currToken.end, this.advance();
+    return this.lexer.getInput().slice(t, n);
+  }
+  ensureParticipant(t, n) {
+    t.participants.find((r) => r.id === n) || t.participants.push({
+      id: n,
+      name: n,
+      type: "participant"
+    });
+  }
+}
+const At = {
+  parse: (e) => {
+    const t = new Et(e);
+    return new Nt(t).parse();
+  }
+}, H = class H {
+  static register(t, n) {
+    this.parsers.set(t, n);
+  }
+  static getParser(t) {
+    const n = this.parsers.get(t);
+    if (!n)
+      throw new Error(`Parser for language '${t}' not found.`);
+    return n;
+  }
+};
+be(H, "parsers", /* @__PURE__ */ new Map()), H.register("mermaid", At);
+let ce = H;
+class Rt {
+  constructor(t) {
+    this.visitor = t;
+  }
+  traverse(t) {
+    this.visitor.visitRoot(t);
+  }
+  /**
+   * Dispatches a single event node to the appropriate visitor method.
+   * This is public so Visitors can call it recursively (e.g. inside Fragments/Groups).
+   */
+  dispatchEvent(t) {
+    switch (t.kind) {
+      case "message":
+        this.visitor.visitMessage(t);
+        break;
+      case "fragment":
+        this.visitor.visitFragment(t);
+        break;
+      case "note":
+        this.visitor.visitNote(t);
+        break;
+      case "activation":
+        this.visitor.visitActivation(t);
+        break;
+      case "divider":
+        this.visitor.visitDivider(t);
+        break;
+      case "spacer":
+        this.visitor.visitSpacer(t);
+        break;
+      case "ref":
+        this.visitor.visitReference(t);
+        break;
+    }
+  }
+  /**
+   * Helper to iterate over a list of events.
+   */
+  dispatchEvents(t) {
+    for (const n of t)
+      this.dispatchEvent(n);
+  }
+}
+class Ct {
+  lines = [];
+  indentLevel = 0;
+  traverser;
+  constructor() {
+    this.traverser = new Rt(this);
+  }
+  generate(t) {
+    return this.lines = [], this.indentLevel = 0, this.traverser.traverse(t), this.lines.join(`
+`);
+  }
+  visitRoot(t) {
+    this.lines.push("sequenceDiagram"), this.indentLevel++, t.meta?.title && this.add(`title ${t.meta.title}`);
+    for (const n of t.participants)
+      this.visitParticipant(n);
+    this.traverser.dispatchEvents(t.events);
+  }
+  visitParticipant(t) {
+    const n = t.type === "actor" ? "actor" : "participant", r = t.name;
+    t.id === t.name ? this.add(`${n} ${t.id}`) : this.add(`${n} ${t.id} as ${r}`);
+  }
+  visitParticipantGroup(t) {
+    let n = "box";
+    t.style?.backgroundColor && (n += ` ${t.style.backgroundColor}`), t.name && (n += ` ${t.name}`), this.add(n);
+  }
+  visitMessage(t) {
+    const n = t.from ?? "[*]", r = t.to ?? "[*]", o = Pt(t.type, t.style);
+    let i = "";
+    t.lifecycle?.activateTarget && (i += "+"), t.lifecycle?.deactivateSource && (i += "-"), this.add(`${n}${o}${i}${r}: ${t.text}`);
+  }
+  visitFragment(t) {
+    if (t.branches.length === 0) return;
+    const n = t.branches[0], r = n.condition ? ` ${n.condition}` : "";
+    this.add(`${t.operator}${r}`), this.indent(() => {
+      this.traverser.dispatchEvents(n.events);
+    });
+    for (let o = 1; o < t.branches.length; o++) {
+      const i = t.branches[o], s = i.condition ? ` ${i.condition}` : "";
+      this.add(`else${s}`), this.indent(() => {
+        this.traverser.dispatchEvents(i.events);
+      });
+    }
+    this.add("end");
+  }
+  visitNote(t) {
+    const n = t.position;
+    let r = "";
+    t.participantIds.length > 0 && (r = t.participantIds.join(","), n !== "over" ? r = ` of ${r}` : r = ` ${r}`), this.add(`note ${n}${r}: ${t.text}`);
+  }
+  visitActivation(t) {
+    this.add(`${t.action} ${t.participantId}`);
+  }
+  visitDivider(t) {
+    this.add(`%% == ${t.text || ""} ==`);
+  }
+  visitSpacer(t) {
+    this.add(`...${t.text || ""}...`);
+  }
+  visitReference(t) {
+    this.add(`%% ref: ${t.text}`);
+  }
+  // --- Helpers ---
+  add(t) {
+    const n = "    ".repeat(this.indentLevel);
+    this.lines.push(`${n}${t}`);
+  }
+  indent(t) {
+    this.indentLevel++, t(), this.indentLevel--;
+  }
+}
+class Q {
+  transform(t) {
+    const n = this.mapEvents(t.events);
+    return {
+      ...t,
+      events: n
+    };
+  }
+  mapEvents(t) {
+    return t.flatMap((n) => this.visitEvent(n));
+  }
+  visitEvent(t) {
+    return t.kind === "fragment" ? this.visitFragment(t) : [t];
+  }
+  visitFragment(t) {
+    const n = t.branches.map((r) => this.visitBranch(r));
+    return [{
+      ...t,
+      branches: n
+    }];
+  }
+  visitBranch(t) {
+    return {
+      ...t,
+      events: this.mapEvents(t.events)
+    };
+  }
+}
+class xt extends Q {
+  visitFragment(t) {
+    const n = super.visitFragment(t);
+    if (n.length === 0) return [];
+    const r = n[0], o = r.branches.filter((i) => i.events.length > 0);
+    return o.length === 0 ? [] : [{
+      ...r,
+      branches: o
+    }];
+  }
+}
+class jt {
+  transform(t) {
+    const n = this.collectUsedParticipants(t.events), r = t.participants.filter((i) => n.has(i.id)), o = t.groups.map((i) => ({
+      ...i,
+      participantIds: i.participantIds.filter((s) => n.has(s))
+    })).filter((i) => i.participantIds.length > 0);
+    return {
+      ...t,
+      participants: r,
+      groups: o
+    };
+  }
+  collectUsedParticipants(t) {
+    const n = /* @__PURE__ */ new Set();
+    function r(o) {
+      for (const i of o)
+        switch (i.kind) {
+          case "message":
+            i.from && n.add(i.from), i.to && n.add(i.to);
+            break;
+          case "fragment":
+            for (const s of i.branches)
+              r(s.events);
+            break;
+          case "activation":
+            n.add(i.participantId);
+            break;
+          case "note":
+            i.participantIds.forEach((s) => n.add(s));
+            break;
+          case "ref":
+            i.participantIds.forEach((s) => n.add(s));
+            break;
+        }
+    }
+    return r(t), n;
+  }
+}
+class fe {
+  // -- Branch / Fragment --
+  matchBranch(t, n, r) {
+    return !(n.operator && !(Array.isArray(n.operator) ? n.operator : [n.operator]).includes(r) || n.condition && (!t.condition || !this.matchText(t.condition, n.condition)));
+  }
+  // -- Participant --
+  matchParticipant(t, n) {
+    return !(n.id && !this.matchText(t.id, n.id) || n.name && !this.matchText(t.name, n.name) || n.stereotype && t.stereotype && !this.matchText(t.stereotype, n.stereotype));
+  }
+  // -- Message --
+  matchMessage(t, n) {
+    return !(n.text && !this.matchText(t.text, n.text) || n.from && t.from && !this.matchText(t.from, n.from) || n.to && t.to && !this.matchText(t.to, n.to));
+  }
+  // -- Group --
+  matchGroup(t, n) {
+    return !(n.name && t.name && !this.matchText(t.name, n.name));
+  }
+  // -- Helpers --
+  matchText(t, n) {
+    if (typeof n == "string")
+      return t === n;
+    if (n instanceof RegExp)
+      return n.test(t);
+    if (typeof n == "object" && n.pattern) {
+      const r = n.flags || "";
+      return new RegExp(n.pattern, r).test(t);
+    }
+    return !1;
+  }
+}
+class Dt extends Q {
+  constructor(t) {
+    super(), this.layer = t;
+  }
+  matcher = new fe();
+  targetParticipantIds = /* @__PURE__ */ new Set();
+  transform(t) {
+    return this.resolveTargetParticipants(t), super.transform(t);
+  }
+  resolveTargetParticipants(t) {
+    this.targetParticipantIds.clear();
+    const n = this.layer.selector;
+    t.participants.forEach((r) => {
+      this.matcher.matchParticipant(r, n) && this.targetParticipantIds.add(r.id);
+    });
+  }
+  visitEvent(t) {
+    if (t.kind === "message") {
+      const n = t;
+      if (!this.isRelatedToParticipant(n))
+        return [];
+    }
+    if (t.kind === "note" && !t.participantIds.some((o) => this.targetParticipantIds.has(o)))
+      return [];
+    if (t.kind === "activation") {
+      const n = t;
+      if (!this.targetParticipantIds.has(n.participantId))
+        return [];
+    }
+    return super.visitEvent(t);
+  }
+  // Helper to check if message involves the participant from selector
+  isRelatedToParticipant(t) {
+    return !!(t.from && this.targetParticipantIds.has(t.from) || t.to && this.targetParticipantIds.has(t.to));
+  }
+}
+class Lt extends Q {
+  constructor(t) {
+    super(), this.layer = t;
+  }
+  matcher = new fe();
+  removedParticipantIds = /* @__PURE__ */ new Set();
+  transform(t) {
+    const n = this.layer.selector;
+    return n.kind === "participant" && (t.participants.forEach((r) => {
+      this.matcher.matchParticipant(r, n) && this.removedParticipantIds.add(r.id);
+    }), t.participants = t.participants.filter((r) => !this.removedParticipantIds.has(r.id))), n.kind === "group" && (t.groups = t.groups.filter((r) => !this.matcher.matchGroup(r, n))), super.transform(t);
+  }
+  visitEvent(t) {
+    const n = this.layer.selector;
+    if (n.kind === "message" && t.kind === "message" && this.matcher.matchMessage(t, n))
+      return [];
+    if (n.kind === "participant") {
+      if (t.kind === "message") {
+        const r = t;
+        if (this.isRelatedToRemovedParticipant(r)) return [];
+      }
+      if (t.kind === "note" && t.participantIds.some((i) => this.removedParticipantIds.has(i)))
+        return [];
+      if (t.kind === "activation") {
+        const r = t;
+        if (this.removedParticipantIds.has(r.participantId)) return [];
+      }
+    }
+    return super.visitEvent(t);
+  }
+  isRelatedToRemovedParticipant(t) {
+    return !!(t.from && this.removedParticipantIds.has(t.from) || t.to && this.removedParticipantIds.has(t.to));
+  }
+}
+class Ft extends Q {
+  constructor(t) {
+    super(), this.layer = t;
+  }
+  matcher = new fe();
+  visitFragment(t) {
+    const n = t.branches.find(
+      (r) => this.matcher.matchBranch(r, this.layer.selector, t.operator)
+    );
+    return n ? this.mapEvents(n.events) : super.visitFragment(t);
+  }
+}
+class Mt {
+  factories = /* @__PURE__ */ new Map();
+  constructor() {
+    this.register("resolve", (t) => new Ft(t)), this.register("focus", (t) => new Dt(t)), this.register("remove", (t) => new Lt(t));
+  }
+  register(t, n) {
+    this.factories.set(t, n);
+  }
+  get(t) {
+    const n = this.factories.get(t.action);
+    return n ? n(t) : null;
+  }
+}
+const Ut = new Mt();
+class ue {
+  transform(t, n) {
+    let r = t;
+    for (const o of n) {
+      const i = Ut.get(o);
+      i ? r = i.transform(r) : console.warn(`Unknown action: ${o.action}`);
+    }
+    return r = new xt().transform(r), r = new jt().transform(r), r;
+  }
+}
+function As(e) {
+  if (typeof e != "object" || e === null)
+    return !1;
+  const t = e;
+  if (Reflect.has(t, "name") && typeof t.name != "string" || !Array.isArray(t.layers))
+    return !1;
+  for (const n of t.layers)
+    if (!Jt(n))
+      return !1;
+  return !0;
+}
+function Jt(e) {
+  if (typeof e != "object" || e === null)
+    return !1;
+  const t = e;
+  return !(typeof t.action != "string" || !["focus", "remove", "resolve"].includes(t.action) || typeof t.selector != "object" || t.selector === null || typeof t.selector.kind != "string");
+}
+function Rs(e, t) {
+  return new ue().transform(e, t.layers);
+}
+class Cs {
+  constructor() {
+  }
+  /**
+   * Initialize a new Polagram transformation pipeline.
+   * @param code Source diagram code
+   * @param format Input format (currently only 'mermaid' is supported)
+   */
+  static init(t, n = "mermaid") {
+    const o = ce.getParser(n).parse(t);
+    return new Vt(o);
+  }
+}
+class Vt {
+  ast;
+  layers = [];
+  constructor(t) {
+    this.ast = t;
+  }
+  // -- Entity Filtering --
+  /**
+   * Focus on specific participants. 
+   * Keeps only interactions involving the matched participants.
+   * @param selector Name (string/RegExp) or detailed ParticipantSelector
+   */
+  focusParticipant(t) {
+    return this.layers.push({
+      action: "focus",
+      selector: this.normalizeParticipantSelector(t)
+    }), this;
+  }
+  /**
+   * Remove specific participants and their interactions.
+   * @param selector Name (string/RegExp) or detailed ParticipantSelector
+   */
+  removeParticipant(t) {
+    return this.layers.push({
+      action: "remove",
+      selector: this.normalizeParticipantSelector(t)
+    }), this;
+  }
+  // -- Message Filtering --
+  /**
+   * Remove specific messages.
+   * @param selector Message text (string/RegExp) or detailed MessageSelector
+   */
+  removeMessage(t) {
+    return this.layers.push({
+      action: "remove",
+      selector: this.normalizeMessageSelector(t)
+    }), this;
+  }
+  // -- Group Filtering --
+  /**
+   * Remove specific groups (visual boxes).
+   * @param selector Group name (string/RegExp) or detailed GroupSelector
+   */
+  removeGroup(t) {
+    return this.layers.push({
+      action: "remove",
+      selector: this.normalizeGroupSelector(t)
+    }), this;
+  }
+  // -- Structural Resolution --
+  /**
+   * Resolve (unwrap) specific fragments like 'alt', 'opt', 'loop'.
+   * Promotes the content of the matched branch and removes the wrapper.
+   * @param selector Condition text (string/RegExp) or detailed FragmentSelector
+   */
+  resolveFragment(t) {
+    return this.layers.push({
+      action: "resolve",
+      selector: this.normalizeFragmentSelector(t)
+    }), this;
+  }
+  /**
+   * Apply a Lens (a named set of transformation layers).
+   * @param lens Lens object containing layers
+   */
+  applyLens(t) {
+    return this.layers.push(...t.layers), this;
+  }
+  /**
+   * Generate Mermaid code from the transformed AST.
+   */
+  toMermaid() {
+    const n = new ue().transform(this.ast, this.layers);
+    return new Ct().generate(n);
+  }
+  /**
+   * Get the transformed AST (for advanced use cases).
+   */
+  toAST() {
+    return new ue().transform(this.ast, this.layers);
+  }
+  // -- Helper Methods --
+  normalizeParticipantSelector(t) {
+    return this.isTextMatcher(t) ? { kind: "participant", name: t } : { kind: "participant", ...t };
+  }
+  normalizeMessageSelector(t) {
+    return this.isTextMatcher(t) ? { kind: "message", text: t } : { kind: "message", ...t };
+  }
+  normalizeGroupSelector(t) {
+    return this.isTextMatcher(t) ? { kind: "group", name: t } : { kind: "group", ...t };
+  }
+  normalizeFragmentSelector(t) {
+    return this.isTextMatcher(t) ? { kind: "fragment", condition: t } : { kind: "fragment", ...t };
+  }
+  isTextMatcher(t) {
+    return typeof t == "string" || t instanceof RegExp || typeof t == "object" && t !== null && "pattern" in t && !("kind" in t);
+  }
+}
+function c(e, t, n) {
+  function r(a, u) {
+    if (a._zod || Object.defineProperty(a, "_zod", {
+      value: {
+        def: u,
+        constr: s,
+        traits: /* @__PURE__ */ new Set()
+      },
+      enumerable: !1
+    }), a._zod.traits.has(e))
+      return;
+    a._zod.traits.add(e), t(a, u);
+    const l = s.prototype, p = Object.keys(l);
+    for (let f = 0; f < p.length; f++) {
+      const d = p[f];
+      d in a || (a[d] = l[d].bind(a));
+    }
+  }
+  const o = n?.Parent ?? Object;
+  class i extends o {
+  }
+  Object.defineProperty(i, "name", { value: e });
+  function s(a) {
+    var u;
+    const l = n?.Parent ? new i() : this;
+    r(l, a), (u = l._zod).deferred ?? (u.deferred = []);
+    for (const p of l._zod.deferred)
+      p();
+    return l;
+  }
+  return Object.defineProperty(s, "init", { value: r }), Object.defineProperty(s, Symbol.hasInstance, {
+    value: (a) => n?.Parent && a instanceof n.Parent ? !0 : a?._zod?.traits?.has(e)
+  }), Object.defineProperty(s, "name", { value: e }), s;
+}
+class D extends Error {
+  constructor() {
+    super("Encountered Promise during synchronous parse. Use .parseAsync() instead.");
+  }
+}
+class We extends Error {
+  constructor(t) {
+    super(`Encountered unidirectional transform during encode: ${t}`), this.name = "ZodEncodeError";
+  }
+}
+const Be = {};
+function A(e) {
+  return Be;
+}
+function Ke(e) {
+  const t = Object.values(e).filter((r) => typeof r == "number");
+  return Object.entries(e).filter(([r, o]) => t.indexOf(+r) === -1).map(([r, o]) => o);
+}
+function le(e, t) {
+  return typeof t == "bigint" ? t.toString() : t;
+}
+function ee(e) {
+  return {
+    get value() {
+      {
+        const t = e();
+        return Object.defineProperty(this, "value", { value: t }), t;
+      }
+    }
+  };
+}
+function de(e) {
+  return e == null;
+}
+function me(e) {
+  const t = e.startsWith("^") ? 1 : 0, n = e.endsWith("$") ? e.length - 1 : e.length;
+  return e.slice(t, n);
+}
+function Gt(e, t) {
+  const n = (e.toString().split(".")[1] || "").length, r = t.toString();
+  let o = (r.split(".")[1] || "").length;
+  if (o === 0 && /\d?e-\d?/.test(r)) {
+    const u = r.match(/\d?e-(\d?)/);
+    u?.[1] && (o = Number.parseInt(u[1]));
+  }
+  const i = n > o ? n : o, s = Number.parseInt(e.toFixed(i).replace(".", "")), a = Number.parseInt(t.toFixed(i).replace(".", ""));
+  return s % a / 10 ** i;
+}
+const ze = /* @__PURE__ */ Symbol("evaluating");
+function m(e, t, n) {
+  let r;
+  Object.defineProperty(e, t, {
+    get() {
+      if (r !== ze)
+        return r === void 0 && (r = ze, r = n()), r;
+    },
+    set(o) {
+      Object.defineProperty(e, t, {
+        value: o
+        // configurable: true,
+      });
+    },
+    configurable: !0
+  });
+}
+function C(e, t, n) {
+  Object.defineProperty(e, t, {
+    value: n,
+    writable: !0,
+    enumerable: !0,
+    configurable: !0
+  });
+}
+function x(...e) {
+  const t = {};
+  for (const n of e) {
+    const r = Object.getOwnPropertyDescriptors(n);
+    Object.assign(t, r);
+  }
+  return Object.defineProperties({}, t);
+}
+function $e(e) {
+  return JSON.stringify(e);
+}
+function Wt(e) {
+  return e.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+const qe = "captureStackTrace" in Error ? Error.captureStackTrace : (...e) => {
+};
+function J(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+const Bt = ee(() => {
+  if (typeof navigator < "u" && navigator?.userAgent?.includes("Cloudflare"))
+    return !1;
+  try {
+    const e = Function;
+    return new e(""), !0;
+  } catch {
+    return !1;
+  }
+});
+function V(e) {
+  if (J(e) === !1)
+    return !1;
+  const t = e.constructor;
+  if (t === void 0 || typeof t != "function")
+    return !0;
+  const n = t.prototype;
+  return !(J(n) === !1 || Object.prototype.hasOwnProperty.call(n, "isPrototypeOf") === !1);
+}
+function Xe(e) {
+  return V(e) ? { ...e } : Array.isArray(e) ? [...e] : e;
+}
+const Kt = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
+function L(e) {
+  return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function P(e, t, n) {
+  const r = new e._zod.constr(t ?? e._zod.def);
+  return (!t || n?.parent) && (r._zod.parent = e), r;
+}
+function h(e) {
+  const t = e;
+  if (!t)
+    return {};
+  if (typeof t == "string")
+    return { error: () => t };
+  if (t?.message !== void 0) {
+    if (t?.error !== void 0)
+      throw new Error("Cannot specify both `message` and `error` params");
+    t.error = t.message;
+  }
+  return delete t.message, typeof t.error == "string" ? { ...t, error: () => t.error } : t;
+}
+function qt(e) {
+  return Object.keys(e).filter((t) => e[t]._zod.optin === "optional" && e[t]._zod.optout === "optional");
+}
+const Xt = {
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-34028234663852886e22, 34028234663852886e22],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+function Yt(e, t) {
+  const n = e._zod.def, r = x(e._zod.def, {
+    get shape() {
+      const o = {};
+      for (const i in t) {
+        if (!(i in n.shape))
+          throw new Error(`Unrecognized key: "${i}"`);
+        t[i] && (o[i] = n.shape[i]);
+      }
+      return C(this, "shape", o), o;
+    },
+    checks: []
+  });
+  return P(e, r);
+}
+function Ht(e, t) {
+  const n = e._zod.def, r = x(e._zod.def, {
+    get shape() {
+      const o = { ...e._zod.def.shape };
+      for (const i in t) {
+        if (!(i in n.shape))
+          throw new Error(`Unrecognized key: "${i}"`);
+        t[i] && delete o[i];
+      }
+      return C(this, "shape", o), o;
+    },
+    checks: []
+  });
+  return P(e, r);
+}
+function Qt(e, t) {
+  if (!V(t))
+    throw new Error("Invalid input to extend: expected a plain object");
+  const n = e._zod.def.checks;
+  if (n && n.length > 0)
+    throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+  const o = x(e._zod.def, {
+    get shape() {
+      const i = { ...e._zod.def.shape, ...t };
+      return C(this, "shape", i), i;
+    },
+    checks: []
+  });
+  return P(e, o);
+}
+function en(e, t) {
+  if (!V(t))
+    throw new Error("Invalid input to safeExtend: expected a plain object");
+  const n = {
+    ...e._zod.def,
+    get shape() {
+      const r = { ...e._zod.def.shape, ...t };
+      return C(this, "shape", r), r;
+    },
+    checks: e._zod.def.checks
+  };
+  return P(e, n);
+}
+function tn(e, t) {
+  const n = x(e._zod.def, {
+    get shape() {
+      const r = { ...e._zod.def.shape, ...t._zod.def.shape };
+      return C(this, "shape", r), r;
+    },
+    get catchall() {
+      return t._zod.def.catchall;
+    },
+    checks: []
+    // delete existing checks
+  });
+  return P(e, n);
+}
+function nn(e, t, n) {
+  const r = x(t._zod.def, {
+    get shape() {
+      const o = t._zod.def.shape, i = { ...o };
+      if (n)
+        for (const s in n) {
+          if (!(s in o))
+            throw new Error(`Unrecognized key: "${s}"`);
+          n[s] && (i[s] = e ? new e({
+            type: "optional",
+            innerType: o[s]
+          }) : o[s]);
+        }
+      else
+        for (const s in o)
+          i[s] = e ? new e({
+            type: "optional",
+            innerType: o[s]
+          }) : o[s];
+      return C(this, "shape", i), i;
+    },
+    checks: []
+  });
+  return P(t, r);
+}
+function rn(e, t, n) {
+  const r = x(t._zod.def, {
+    get shape() {
+      const o = t._zod.def.shape, i = { ...o };
+      if (n)
+        for (const s in n) {
+          if (!(s in i))
+            throw new Error(`Unrecognized key: "${s}"`);
+          n[s] && (i[s] = new e({
+            type: "nonoptional",
+            innerType: o[s]
+          }));
+        }
+      else
+        for (const s in o)
+          i[s] = new e({
+            type: "nonoptional",
+            innerType: o[s]
+          });
+      return C(this, "shape", i), i;
+    },
+    checks: []
+  });
+  return P(t, r);
+}
+function j(e, t = 0) {
+  if (e.aborted === !0)
+    return !0;
+  for (let n = t; n < e.issues.length; n++)
+    if (e.issues[n]?.continue !== !0)
+      return !0;
+  return !1;
+}
+function Ye(e, t) {
+  return t.map((n) => {
+    var r;
+    return (r = n).path ?? (r.path = []), n.path.unshift(e), n;
+  });
+}
+function W(e) {
+  return typeof e == "string" ? e : e?.message;
+}
+function R(e, t, n) {
+  const r = { ...e, path: e.path ?? [] };
+  if (!e.message) {
+    const o = W(e.inst?._zod.def?.error?.(e)) ?? W(t?.error?.(e)) ?? W(n.customError?.(e)) ?? W(n.localeError?.(e)) ?? "Invalid input";
+    r.message = o;
+  }
+  return delete r.inst, delete r.continue, t?.reportInput || delete r.input, r;
+}
+function ge(e) {
+  return Array.isArray(e) ? "array" : typeof e == "string" ? "string" : "unknown";
+}
+function G(...e) {
+  const [t, n, r] = e;
+  return typeof t == "string" ? {
+    message: t,
+    code: "custom",
+    input: n,
+    inst: r
+  } : { ...t };
+}
+const He = (e, t) => {
+  e.name = "$ZodError", Object.defineProperty(e, "_zod", {
+    value: e._zod,
+    enumerable: !1
+  }), Object.defineProperty(e, "issues", {
+    value: t,
+    enumerable: !1
+  }), e.message = JSON.stringify(t, le, 2), Object.defineProperty(e, "toString", {
+    value: () => e.message,
+    enumerable: !1
+  });
+}, Qe = c("$ZodError", He), et = c("$ZodError", He, { Parent: Error });
+function on(e, t = (n) => n.message) {
+  const n = {}, r = [];
+  for (const o of e.issues)
+    o.path.length > 0 ? (n[o.path[0]] = n[o.path[0]] || [], n[o.path[0]].push(t(o))) : r.push(t(o));
+  return { formErrors: r, fieldErrors: n };
+}
+function sn(e, t = (n) => n.message) {
+  const n = { _errors: [] }, r = (o) => {
+    for (const i of o.issues)
+      if (i.code === "invalid_union" && i.errors.length)
+        i.errors.map((s) => r({ issues: s }));
+      else if (i.code === "invalid_key")
+        r({ issues: i.issues });
+      else if (i.code === "invalid_element")
+        r({ issues: i.issues });
+      else if (i.path.length === 0)
+        n._errors.push(t(i));
+      else {
+        let s = n, a = 0;
+        for (; a < i.path.length; ) {
+          const u = i.path[a];
+          a === i.path.length - 1 ? (s[u] = s[u] || { _errors: [] }, s[u]._errors.push(t(i))) : s[u] = s[u] || { _errors: [] }, s = s[u], a++;
+        }
+      }
+  };
+  return r(e), n;
+}
+const ve = (e) => (t, n, r, o) => {
+  const i = r ? Object.assign(r, { async: !1 }) : { async: !1 }, s = t._zod.run({ value: n, issues: [] }, i);
+  if (s instanceof Promise)
+    throw new D();
+  if (s.issues.length) {
+    const a = new (o?.Err ?? e)(s.issues.map((u) => R(u, i, A())));
+    throw qe(a, o?.callee), a;
+  }
+  return s.value;
+}, _e = (e) => async (t, n, r, o) => {
+  const i = r ? Object.assign(r, { async: !0 }) : { async: !0 };
+  let s = t._zod.run({ value: n, issues: [] }, i);
+  if (s instanceof Promise && (s = await s), s.issues.length) {
+    const a = new (o?.Err ?? e)(s.issues.map((u) => R(u, i, A())));
+    throw qe(a, o?.callee), a;
+  }
+  return s.value;
+}, te = (e) => (t, n, r) => {
+  const o = r ? { ...r, async: !1 } : { async: !1 }, i = t._zod.run({ value: n, issues: [] }, o);
+  if (i instanceof Promise)
+    throw new D();
+  return i.issues.length ? {
+    success: !1,
+    error: new (e ?? Qe)(i.issues.map((s) => R(s, o, A())))
+  } : { success: !0, data: i.value };
+}, an = /* @__PURE__ */ te(et), ne = (e) => async (t, n, r) => {
+  const o = r ? Object.assign(r, { async: !0 }) : { async: !0 };
+  let i = t._zod.run({ value: n, issues: [] }, o);
+  return i instanceof Promise && (i = await i), i.issues.length ? {
+    success: !1,
+    error: new e(i.issues.map((s) => R(s, o, A())))
+  } : { success: !0, data: i.value };
+}, cn = /* @__PURE__ */ ne(et), un = (e) => (t, n, r) => {
+  const o = r ? Object.assign(r, { direction: "backward" }) : { direction: "backward" };
+  return ve(e)(t, n, o);
+}, ln = (e) => (t, n, r) => ve(e)(t, n, r), pn = (e) => async (t, n, r) => {
+  const o = r ? Object.assign(r, { direction: "backward" }) : { direction: "backward" };
+  return _e(e)(t, n, o);
+}, hn = (e) => async (t, n, r) => _e(e)(t, n, r), fn = (e) => (t, n, r) => {
+  const o = r ? Object.assign(r, { direction: "backward" }) : { direction: "backward" };
+  return te(e)(t, n, o);
+}, dn = (e) => (t, n, r) => te(e)(t, n, r), mn = (e) => async (t, n, r) => {
+  const o = r ? Object.assign(r, { direction: "backward" }) : { direction: "backward" };
+  return ne(e)(t, n, o);
+}, gn = (e) => async (t, n, r) => ne(e)(t, n, r), vn = /^[cC][^\s-]{8,}$/, _n = /^[0-9a-z]+$/, yn = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/, kn = /^[0-9a-vA-V]{20}$/, wn = /^[A-Za-z0-9]{27}$/, bn = /^[a-zA-Z0-9_-]{21}$/, zn = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/, $n = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/, Te = (e) => e ? new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${e}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`) : /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/, Tn = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/, Zn = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+function In() {
+  return new RegExp(Zn, "u");
+}
+const En = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/, Sn = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/, On = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/, Pn = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/, Nn = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/, tt = /^[A-Za-z0-9_-]*$/, An = /^\+(?:[0-9]){6,14}[0-9]$/, nt = "(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))", Rn = /* @__PURE__ */ new RegExp(`^${nt}$`);
+function rt(e) {
+  const t = "(?:[01]\\d|2[0-3]):[0-5]\\d";
+  return typeof e.precision == "number" ? e.precision === -1 ? `${t}` : e.precision === 0 ? `${t}:[0-5]\\d` : `${t}:[0-5]\\d\\.\\d{${e.precision}}` : `${t}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+}
+function Cn(e) {
+  return new RegExp(`^${rt(e)}$`);
+}
+function xn(e) {
+  const t = rt({ precision: e.precision }), n = ["Z"];
+  e.local && n.push(""), e.offset && n.push("([+-](?:[01]\\d|2[0-3]):[0-5]\\d)");
+  const r = `${t}(?:${n.join("|")})`;
+  return new RegExp(`^${nt}T(?:${r})$`);
+}
+const jn = (e) => {
+  const t = e ? `[\\s\\S]{${e?.minimum ?? 0},${e?.maximum ?? ""}}` : "[\\s\\S]*";
+  return new RegExp(`^${t}$`);
+}, Dn = /^-?\d+$/, Ln = /^-?\d+(?:\.\d+)?/, Fn = /^[^A-Z]*$/, Mn = /^[^a-z]*$/, z = /* @__PURE__ */ c("$ZodCheck", (e, t) => {
+  var n;
+  e._zod ?? (e._zod = {}), e._zod.def = t, (n = e._zod).onattach ?? (n.onattach = []);
+}), ot = {
+  number: "number",
+  bigint: "bigint",
+  object: "date"
+}, it = /* @__PURE__ */ c("$ZodCheckLessThan", (e, t) => {
+  z.init(e, t);
+  const n = ot[typeof t.value];
+  e._zod.onattach.push((r) => {
+    const o = r._zod.bag, i = (t.inclusive ? o.maximum : o.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
+    t.value < i && (t.inclusive ? o.maximum = t.value : o.exclusiveMaximum = t.value);
+  }), e._zod.check = (r) => {
+    (t.inclusive ? r.value <= t.value : r.value < t.value) || r.issues.push({
+      origin: n,
+      code: "too_big",
+      maximum: t.value,
+      input: r.value,
+      inclusive: t.inclusive,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), st = /* @__PURE__ */ c("$ZodCheckGreaterThan", (e, t) => {
+  z.init(e, t);
+  const n = ot[typeof t.value];
+  e._zod.onattach.push((r) => {
+    const o = r._zod.bag, i = (t.inclusive ? o.minimum : o.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+    t.value > i && (t.inclusive ? o.minimum = t.value : o.exclusiveMinimum = t.value);
+  }), e._zod.check = (r) => {
+    (t.inclusive ? r.value >= t.value : r.value > t.value) || r.issues.push({
+      origin: n,
+      code: "too_small",
+      minimum: t.value,
+      input: r.value,
+      inclusive: t.inclusive,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), Un = /* @__PURE__ */ c("$ZodCheckMultipleOf", (e, t) => {
+  z.init(e, t), e._zod.onattach.push((n) => {
+    var r;
+    (r = n._zod.bag).multipleOf ?? (r.multipleOf = t.value);
+  }), e._zod.check = (n) => {
+    if (typeof n.value != typeof t.value)
+      throw new Error("Cannot mix number and bigint in multiple_of check.");
+    (typeof n.value == "bigint" ? n.value % t.value === BigInt(0) : Gt(n.value, t.value) === 0) || n.issues.push({
+      origin: typeof n.value,
+      code: "not_multiple_of",
+      divisor: t.value,
+      input: n.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), Jn = /* @__PURE__ */ c("$ZodCheckNumberFormat", (e, t) => {
+  z.init(e, t), t.format = t.format || "float64";
+  const n = t.format?.includes("int"), r = n ? "int" : "number", [o, i] = Xt[t.format];
+  e._zod.onattach.push((s) => {
+    const a = s._zod.bag;
+    a.format = t.format, a.minimum = o, a.maximum = i, n && (a.pattern = Dn);
+  }), e._zod.check = (s) => {
+    const a = s.value;
+    if (n) {
+      if (!Number.isInteger(a)) {
+        s.issues.push({
+          expected: r,
+          format: t.format,
+          code: "invalid_type",
+          continue: !1,
+          input: a,
+          inst: e
+        });
+        return;
+      }
+      if (!Number.isSafeInteger(a)) {
+        a > 0 ? s.issues.push({
+          input: a,
+          code: "too_big",
+          maximum: Number.MAX_SAFE_INTEGER,
+          note: "Integers must be within the safe integer range.",
+          inst: e,
+          origin: r,
+          continue: !t.abort
+        }) : s.issues.push({
+          input: a,
+          code: "too_small",
+          minimum: Number.MIN_SAFE_INTEGER,
+          note: "Integers must be within the safe integer range.",
+          inst: e,
+          origin: r,
+          continue: !t.abort
+        });
+        return;
+      }
+    }
+    a < o && s.issues.push({
+      origin: "number",
+      input: a,
+      code: "too_small",
+      minimum: o,
+      inclusive: !0,
+      inst: e,
+      continue: !t.abort
+    }), a > i && s.issues.push({
+      origin: "number",
+      input: a,
+      code: "too_big",
+      maximum: i,
+      inst: e
+    });
+  };
+}), Vn = /* @__PURE__ */ c("$ZodCheckMaxLength", (e, t) => {
+  var n;
+  z.init(e, t), (n = e._zod.def).when ?? (n.when = (r) => {
+    const o = r.value;
+    return !de(o) && o.length !== void 0;
+  }), e._zod.onattach.push((r) => {
+    const o = r._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
+    t.maximum < o && (r._zod.bag.maximum = t.maximum);
+  }), e._zod.check = (r) => {
+    const o = r.value;
+    if (o.length <= t.maximum)
+      return;
+    const s = ge(o);
+    r.issues.push({
+      origin: s,
+      code: "too_big",
+      maximum: t.maximum,
+      inclusive: !0,
+      input: o,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), Gn = /* @__PURE__ */ c("$ZodCheckMinLength", (e, t) => {
+  var n;
+  z.init(e, t), (n = e._zod.def).when ?? (n.when = (r) => {
+    const o = r.value;
+    return !de(o) && o.length !== void 0;
+  }), e._zod.onattach.push((r) => {
+    const o = r._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
+    t.minimum > o && (r._zod.bag.minimum = t.minimum);
+  }), e._zod.check = (r) => {
+    const o = r.value;
+    if (o.length >= t.minimum)
+      return;
+    const s = ge(o);
+    r.issues.push({
+      origin: s,
+      code: "too_small",
+      minimum: t.minimum,
+      inclusive: !0,
+      input: o,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), Wn = /* @__PURE__ */ c("$ZodCheckLengthEquals", (e, t) => {
+  var n;
+  z.init(e, t), (n = e._zod.def).when ?? (n.when = (r) => {
+    const o = r.value;
+    return !de(o) && o.length !== void 0;
+  }), e._zod.onattach.push((r) => {
+    const o = r._zod.bag;
+    o.minimum = t.length, o.maximum = t.length, o.length = t.length;
+  }), e._zod.check = (r) => {
+    const o = r.value, i = o.length;
+    if (i === t.length)
+      return;
+    const s = ge(o), a = i > t.length;
+    r.issues.push({
+      origin: s,
+      ...a ? { code: "too_big", maximum: t.length } : { code: "too_small", minimum: t.length },
+      inclusive: !0,
+      exact: !0,
+      input: r.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), re = /* @__PURE__ */ c("$ZodCheckStringFormat", (e, t) => {
+  var n, r;
+  z.init(e, t), e._zod.onattach.push((o) => {
+    const i = o._zod.bag;
+    i.format = t.format, t.pattern && (i.patterns ?? (i.patterns = /* @__PURE__ */ new Set()), i.patterns.add(t.pattern));
+  }), t.pattern ? (n = e._zod).check ?? (n.check = (o) => {
+    t.pattern.lastIndex = 0, !t.pattern.test(o.value) && o.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: t.format,
+      input: o.value,
+      ...t.pattern ? { pattern: t.pattern.toString() } : {},
+      inst: e,
+      continue: !t.abort
+    });
+  }) : (r = e._zod).check ?? (r.check = () => {
+  });
+}), Bn = /* @__PURE__ */ c("$ZodCheckRegex", (e, t) => {
+  re.init(e, t), e._zod.check = (n) => {
+    t.pattern.lastIndex = 0, !t.pattern.test(n.value) && n.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "regex",
+      input: n.value,
+      pattern: t.pattern.toString(),
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), Kn = /* @__PURE__ */ c("$ZodCheckLowerCase", (e, t) => {
+  t.pattern ?? (t.pattern = Fn), re.init(e, t);
+}), qn = /* @__PURE__ */ c("$ZodCheckUpperCase", (e, t) => {
+  t.pattern ?? (t.pattern = Mn), re.init(e, t);
+}), Xn = /* @__PURE__ */ c("$ZodCheckIncludes", (e, t) => {
+  z.init(e, t);
+  const n = L(t.includes), r = new RegExp(typeof t.position == "number" ? `^.{${t.position}}${n}` : n);
+  t.pattern = r, e._zod.onattach.push((o) => {
+    const i = o._zod.bag;
+    i.patterns ?? (i.patterns = /* @__PURE__ */ new Set()), i.patterns.add(r);
+  }), e._zod.check = (o) => {
+    o.value.includes(t.includes, t.position) || o.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "includes",
+      includes: t.includes,
+      input: o.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), Yn = /* @__PURE__ */ c("$ZodCheckStartsWith", (e, t) => {
+  z.init(e, t);
+  const n = new RegExp(`^${L(t.prefix)}.*`);
+  t.pattern ?? (t.pattern = n), e._zod.onattach.push((r) => {
+    const o = r._zod.bag;
+    o.patterns ?? (o.patterns = /* @__PURE__ */ new Set()), o.patterns.add(n);
+  }), e._zod.check = (r) => {
+    r.value.startsWith(t.prefix) || r.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "starts_with",
+      prefix: t.prefix,
+      input: r.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), Hn = /* @__PURE__ */ c("$ZodCheckEndsWith", (e, t) => {
+  z.init(e, t);
+  const n = new RegExp(`.*${L(t.suffix)}$`);
+  t.pattern ?? (t.pattern = n), e._zod.onattach.push((r) => {
+    const o = r._zod.bag;
+    o.patterns ?? (o.patterns = /* @__PURE__ */ new Set()), o.patterns.add(n);
+  }), e._zod.check = (r) => {
+    r.value.endsWith(t.suffix) || r.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "ends_with",
+      suffix: t.suffix,
+      input: r.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), Qn = /* @__PURE__ */ c("$ZodCheckOverwrite", (e, t) => {
+  z.init(e, t), e._zod.check = (n) => {
+    n.value = t.tx(n.value);
+  };
+});
+class er {
+  constructor(t = []) {
+    this.content = [], this.indent = 0, this && (this.args = t);
+  }
+  indented(t) {
+    this.indent += 1, t(this), this.indent -= 1;
+  }
+  write(t) {
+    if (typeof t == "function") {
+      t(this, { execution: "sync" }), t(this, { execution: "async" });
+      return;
+    }
+    const r = t.split(`
+`).filter((s) => s), o = Math.min(...r.map((s) => s.length - s.trimStart().length)), i = r.map((s) => s.slice(o)).map((s) => " ".repeat(this.indent * 2) + s);
+    for (const s of i)
+      this.content.push(s);
+  }
+  compile() {
+    const t = Function, n = this?.args, o = [...(this?.content ?? [""]).map((i) => `  ${i}`)];
+    return new t(...n, o.join(`
+`));
+  }
+}
+const tr = {
+  major: 4,
+  minor: 2,
+  patch: 1
+}, y = /* @__PURE__ */ c("$ZodType", (e, t) => {
+  var n;
+  e ?? (e = {}), e._zod.def = t, e._zod.bag = e._zod.bag || {}, e._zod.version = tr;
+  const r = [...e._zod.def.checks ?? []];
+  e._zod.traits.has("$ZodCheck") && r.unshift(e);
+  for (const o of r)
+    for (const i of o._zod.onattach)
+      i(e);
+  if (r.length === 0)
+    (n = e._zod).deferred ?? (n.deferred = []), e._zod.deferred?.push(() => {
+      e._zod.run = e._zod.parse;
+    });
+  else {
+    const o = (s, a, u) => {
+      let l = j(s), p;
+      for (const f of a) {
+        if (f._zod.def.when) {
+          if (!f._zod.def.when(s))
+            continue;
+        } else if (l)
+          continue;
+        const d = s.issues.length, v = f._zod.check(s);
+        if (v instanceof Promise && u?.async === !1)
+          throw new D();
+        if (p || v instanceof Promise)
+          p = (p ?? Promise.resolve()).then(async () => {
+            await v, s.issues.length !== d && (l || (l = j(s, d)));
+          });
+        else {
+          if (s.issues.length === d)
+            continue;
+          l || (l = j(s, d));
+        }
+      }
+      return p ? p.then(() => s) : s;
+    }, i = (s, a, u) => {
+      if (j(s))
+        return s.aborted = !0, s;
+      const l = o(a, r, u);
+      if (l instanceof Promise) {
+        if (u.async === !1)
+          throw new D();
+        return l.then((p) => e._zod.parse(p, u));
+      }
+      return e._zod.parse(l, u);
+    };
+    e._zod.run = (s, a) => {
+      if (a.skipChecks)
+        return e._zod.parse(s, a);
+      if (a.direction === "backward") {
+        const l = e._zod.parse({ value: s.value, issues: [] }, { ...a, skipChecks: !0 });
+        return l instanceof Promise ? l.then((p) => i(p, s, a)) : i(l, s, a);
+      }
+      const u = e._zod.parse(s, a);
+      if (u instanceof Promise) {
+        if (a.async === !1)
+          throw new D();
+        return u.then((l) => o(l, r, a));
+      }
+      return o(u, r, a);
+    };
+  }
+  e["~standard"] = {
+    validate: (o) => {
+      try {
+        const i = an(e, o);
+        return i.success ? { value: i.data } : { issues: i.error?.issues };
+      } catch {
+        return cn(e, o).then((s) => s.success ? { value: s.data } : { issues: s.error?.issues });
+      }
+    },
+    vendor: "zod",
+    version: 1
+  };
+}), ye = /* @__PURE__ */ c("$ZodString", (e, t) => {
+  y.init(e, t), e._zod.pattern = [...e?._zod.bag?.patterns ?? []].pop() ?? jn(e._zod.bag), e._zod.parse = (n, r) => {
+    if (t.coerce)
+      try {
+        n.value = String(n.value);
+      } catch {
+      }
+    return typeof n.value == "string" || n.issues.push({
+      expected: "string",
+      code: "invalid_type",
+      input: n.value,
+      inst: e
+    }), n;
+  };
+}), g = /* @__PURE__ */ c("$ZodStringFormat", (e, t) => {
+  re.init(e, t), ye.init(e, t);
+}), nr = /* @__PURE__ */ c("$ZodGUID", (e, t) => {
+  t.pattern ?? (t.pattern = $n), g.init(e, t);
+}), rr = /* @__PURE__ */ c("$ZodUUID", (e, t) => {
+  if (t.version) {
+    const r = {
+      v1: 1,
+      v2: 2,
+      v3: 3,
+      v4: 4,
+      v5: 5,
+      v6: 6,
+      v7: 7,
+      v8: 8
+    }[t.version];
+    if (r === void 0)
+      throw new Error(`Invalid UUID version: "${t.version}"`);
+    t.pattern ?? (t.pattern = Te(r));
+  } else
+    t.pattern ?? (t.pattern = Te());
+  g.init(e, t);
+}), or = /* @__PURE__ */ c("$ZodEmail", (e, t) => {
+  t.pattern ?? (t.pattern = Tn), g.init(e, t);
+}), ir = /* @__PURE__ */ c("$ZodURL", (e, t) => {
+  g.init(e, t), e._zod.check = (n) => {
+    try {
+      const r = n.value.trim(), o = new URL(r);
+      t.hostname && (t.hostname.lastIndex = 0, t.hostname.test(o.hostname) || n.issues.push({
+        code: "invalid_format",
+        format: "url",
+        note: "Invalid hostname",
+        pattern: t.hostname.source,
+        input: n.value,
+        inst: e,
+        continue: !t.abort
+      })), t.protocol && (t.protocol.lastIndex = 0, t.protocol.test(o.protocol.endsWith(":") ? o.protocol.slice(0, -1) : o.protocol) || n.issues.push({
+        code: "invalid_format",
+        format: "url",
+        note: "Invalid protocol",
+        pattern: t.protocol.source,
+        input: n.value,
+        inst: e,
+        continue: !t.abort
+      })), t.normalize ? n.value = o.href : n.value = r;
+      return;
+    } catch {
+      n.issues.push({
+        code: "invalid_format",
+        format: "url",
+        input: n.value,
+        inst: e,
+        continue: !t.abort
+      });
+    }
+  };
+}), sr = /* @__PURE__ */ c("$ZodEmoji", (e, t) => {
+  t.pattern ?? (t.pattern = In()), g.init(e, t);
+}), ar = /* @__PURE__ */ c("$ZodNanoID", (e, t) => {
+  t.pattern ?? (t.pattern = bn), g.init(e, t);
+}), cr = /* @__PURE__ */ c("$ZodCUID", (e, t) => {
+  t.pattern ?? (t.pattern = vn), g.init(e, t);
+}), ur = /* @__PURE__ */ c("$ZodCUID2", (e, t) => {
+  t.pattern ?? (t.pattern = _n), g.init(e, t);
+}), lr = /* @__PURE__ */ c("$ZodULID", (e, t) => {
+  t.pattern ?? (t.pattern = yn), g.init(e, t);
+}), pr = /* @__PURE__ */ c("$ZodXID", (e, t) => {
+  t.pattern ?? (t.pattern = kn), g.init(e, t);
+}), hr = /* @__PURE__ */ c("$ZodKSUID", (e, t) => {
+  t.pattern ?? (t.pattern = wn), g.init(e, t);
+}), fr = /* @__PURE__ */ c("$ZodISODateTime", (e, t) => {
+  t.pattern ?? (t.pattern = xn(t)), g.init(e, t);
+}), dr = /* @__PURE__ */ c("$ZodISODate", (e, t) => {
+  t.pattern ?? (t.pattern = Rn), g.init(e, t);
+}), mr = /* @__PURE__ */ c("$ZodISOTime", (e, t) => {
+  t.pattern ?? (t.pattern = Cn(t)), g.init(e, t);
+}), gr = /* @__PURE__ */ c("$ZodISODuration", (e, t) => {
+  t.pattern ?? (t.pattern = zn), g.init(e, t);
+}), vr = /* @__PURE__ */ c("$ZodIPv4", (e, t) => {
+  t.pattern ?? (t.pattern = En), g.init(e, t), e._zod.bag.format = "ipv4";
+}), _r = /* @__PURE__ */ c("$ZodIPv6", (e, t) => {
+  t.pattern ?? (t.pattern = Sn), g.init(e, t), e._zod.bag.format = "ipv6", e._zod.check = (n) => {
+    try {
+      new URL(`http://[${n.value}]`);
+    } catch {
+      n.issues.push({
+        code: "invalid_format",
+        format: "ipv6",
+        input: n.value,
+        inst: e,
+        continue: !t.abort
+      });
+    }
+  };
+}), yr = /* @__PURE__ */ c("$ZodCIDRv4", (e, t) => {
+  t.pattern ?? (t.pattern = On), g.init(e, t);
+}), kr = /* @__PURE__ */ c("$ZodCIDRv6", (e, t) => {
+  t.pattern ?? (t.pattern = Pn), g.init(e, t), e._zod.check = (n) => {
+    const r = n.value.split("/");
+    try {
+      if (r.length !== 2)
+        throw new Error();
+      const [o, i] = r;
+      if (!i)
+        throw new Error();
+      const s = Number(i);
+      if (`${s}` !== i)
+        throw new Error();
+      if (s < 0 || s > 128)
+        throw new Error();
+      new URL(`http://[${o}]`);
+    } catch {
+      n.issues.push({
+        code: "invalid_format",
+        format: "cidrv6",
+        input: n.value,
+        inst: e,
+        continue: !t.abort
+      });
+    }
+  };
+});
+function at(e) {
+  if (e === "")
+    return !0;
+  if (e.length % 4 !== 0)
+    return !1;
+  try {
+    return atob(e), !0;
+  } catch {
+    return !1;
+  }
+}
+const wr = /* @__PURE__ */ c("$ZodBase64", (e, t) => {
+  t.pattern ?? (t.pattern = Nn), g.init(e, t), e._zod.bag.contentEncoding = "base64", e._zod.check = (n) => {
+    at(n.value) || n.issues.push({
+      code: "invalid_format",
+      format: "base64",
+      input: n.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+});
+function br(e) {
+  if (!tt.test(e))
+    return !1;
+  const t = e.replace(/[-_]/g, (r) => r === "-" ? "+" : "/"), n = t.padEnd(Math.ceil(t.length / 4) * 4, "=");
+  return at(n);
+}
+const zr = /* @__PURE__ */ c("$ZodBase64URL", (e, t) => {
+  t.pattern ?? (t.pattern = tt), g.init(e, t), e._zod.bag.contentEncoding = "base64url", e._zod.check = (n) => {
+    br(n.value) || n.issues.push({
+      code: "invalid_format",
+      format: "base64url",
+      input: n.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), $r = /* @__PURE__ */ c("$ZodE164", (e, t) => {
+  t.pattern ?? (t.pattern = An), g.init(e, t);
+});
+function Tr(e, t = null) {
+  try {
+    const n = e.split(".");
+    if (n.length !== 3)
+      return !1;
+    const [r] = n;
+    if (!r)
+      return !1;
+    const o = JSON.parse(atob(r));
+    return !("typ" in o && o?.typ !== "JWT" || !o.alg || t && (!("alg" in o) || o.alg !== t));
+  } catch {
+    return !1;
+  }
+}
+const Zr = /* @__PURE__ */ c("$ZodJWT", (e, t) => {
+  g.init(e, t), e._zod.check = (n) => {
+    Tr(n.value, t.alg) || n.issues.push({
+      code: "invalid_format",
+      format: "jwt",
+      input: n.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), ct = /* @__PURE__ */ c("$ZodNumber", (e, t) => {
+  y.init(e, t), e._zod.pattern = e._zod.bag.pattern ?? Ln, e._zod.parse = (n, r) => {
+    if (t.coerce)
+      try {
+        n.value = Number(n.value);
+      } catch {
+      }
+    const o = n.value;
+    if (typeof o == "number" && !Number.isNaN(o) && Number.isFinite(o))
+      return n;
+    const i = typeof o == "number" ? Number.isNaN(o) ? "NaN" : Number.isFinite(o) ? void 0 : "Infinity" : void 0;
+    return n.issues.push({
+      expected: "number",
+      code: "invalid_type",
+      input: o,
+      inst: e,
+      ...i ? { received: i } : {}
+    }), n;
+  };
+}), Ir = /* @__PURE__ */ c("$ZodNumberFormat", (e, t) => {
+  Jn.init(e, t), ct.init(e, t);
+}), Er = /* @__PURE__ */ c("$ZodUnknown", (e, t) => {
+  y.init(e, t), e._zod.parse = (n) => n;
+}), Sr = /* @__PURE__ */ c("$ZodNever", (e, t) => {
+  y.init(e, t), e._zod.parse = (n, r) => (n.issues.push({
+    expected: "never",
+    code: "invalid_type",
+    input: n.value,
+    inst: e
+  }), n);
+});
+function Ze(e, t, n) {
+  e.issues.length && t.issues.push(...Ye(n, e.issues)), t.value[n] = e.value;
+}
+const Or = /* @__PURE__ */ c("$ZodArray", (e, t) => {
+  y.init(e, t), e._zod.parse = (n, r) => {
+    const o = n.value;
+    if (!Array.isArray(o))
+      return n.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input: o,
+        inst: e
+      }), n;
+    n.value = Array(o.length);
+    const i = [];
+    for (let s = 0; s < o.length; s++) {
+      const a = o[s], u = t.element._zod.run({
+        value: a,
+        issues: []
+      }, r);
+      u instanceof Promise ? i.push(u.then((l) => Ze(l, n, s))) : Ze(u, n, s);
+    }
+    return i.length ? Promise.all(i).then(() => n) : n;
+  };
+});
+function q(e, t, n, r) {
+  e.issues.length && t.issues.push(...Ye(n, e.issues)), e.value === void 0 ? n in r && (t.value[n] = void 0) : t.value[n] = e.value;
+}
+function ut(e) {
+  const t = Object.keys(e.shape);
+  for (const r of t)
+    if (!e.shape?.[r]?._zod?.traits?.has("$ZodType"))
+      throw new Error(`Invalid element at key "${r}": expected a Zod schema`);
+  const n = qt(e.shape);
+  return {
+    ...e,
+    keys: t,
+    keySet: new Set(t),
+    numKeys: t.length,
+    optionalKeys: new Set(n)
+  };
+}
+function lt(e, t, n, r, o, i) {
+  const s = [], a = o.keySet, u = o.catchall._zod, l = u.def.type;
+  for (const p in t) {
+    if (a.has(p))
+      continue;
+    if (l === "never") {
+      s.push(p);
+      continue;
+    }
+    const f = u.run({ value: t[p], issues: [] }, r);
+    f instanceof Promise ? e.push(f.then((d) => q(d, n, p, t))) : q(f, n, p, t);
+  }
+  return s.length && n.issues.push({
+    code: "unrecognized_keys",
+    keys: s,
+    input: t,
+    inst: i
+  }), e.length ? Promise.all(e).then(() => n) : n;
+}
+const Pr = /* @__PURE__ */ c("$ZodObject", (e, t) => {
+  if (y.init(e, t), !Object.getOwnPropertyDescriptor(t, "shape")?.get) {
+    const a = t.shape;
+    Object.defineProperty(t, "shape", {
+      get: () => {
+        const u = { ...a };
+        return Object.defineProperty(t, "shape", {
+          value: u
+        }), u;
+      }
+    });
+  }
+  const r = ee(() => ut(t));
+  m(e._zod, "propValues", () => {
+    const a = t.shape, u = {};
+    for (const l in a) {
+      const p = a[l]._zod;
+      if (p.values) {
+        u[l] ?? (u[l] = /* @__PURE__ */ new Set());
+        for (const f of p.values)
+          u[l].add(f);
+      }
+    }
+    return u;
+  });
+  const o = J, i = t.catchall;
+  let s;
+  e._zod.parse = (a, u) => {
+    s ?? (s = r.value);
+    const l = a.value;
+    if (!o(l))
+      return a.issues.push({
+        expected: "object",
+        code: "invalid_type",
+        input: l,
+        inst: e
+      }), a;
+    a.value = {};
+    const p = [], f = s.shape;
+    for (const d of s.keys) {
+      const $ = f[d]._zod.run({ value: l[d], issues: [] }, u);
+      $ instanceof Promise ? p.push($.then((ie) => q(ie, a, d, l))) : q($, a, d, l);
+    }
+    return i ? lt(p, l, a, u, r.value, e) : p.length ? Promise.all(p).then(() => a) : a;
+  };
+}), Nr = /* @__PURE__ */ c("$ZodObjectJIT", (e, t) => {
+  Pr.init(e, t);
+  const n = e._zod.parse, r = ee(() => ut(t)), o = (d) => {
+    const v = new er(["shape", "payload", "ctx"]), $ = r.value, ie = (E) => {
+      const Z = $e(E);
+      return `shape[${Z}]._zod.run({ value: input[${Z}], issues: [] }, ctx)`;
+    };
+    v.write("const input = payload.value;");
+    const we = /* @__PURE__ */ Object.create(null);
+    let zt = 0;
+    for (const E of $.keys)
+      we[E] = `key_${zt++}`;
+    v.write("const newResult = {};");
+    for (const E of $.keys) {
+      const Z = we[E], M = $e(E);
+      v.write(`const ${Z} = ${ie(E)};`), v.write(`
+        if (${Z}.issues.length) {
+          payload.issues = payload.issues.concat(${Z}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${M}, ...iss.path] : [${M}]
+          })));
+        }
+        
+        
+        if (${Z}.value === undefined) {
+          if (${M} in input) {
+            newResult[${M}] = undefined;
+          }
+        } else {
+          newResult[${M}] = ${Z}.value;
+        }
+        
+      `);
+    }
+    v.write("payload.value = newResult;"), v.write("return payload;");
+    const $t = v.compile();
+    return (E, Z) => $t(d, E, Z);
+  };
+  let i;
+  const s = J, a = !Be.jitless, l = a && Bt.value, p = t.catchall;
+  let f;
+  e._zod.parse = (d, v) => {
+    f ?? (f = r.value);
+    const $ = d.value;
+    return s($) ? a && l && v?.async === !1 && v.jitless !== !0 ? (i || (i = o(t.shape)), d = i(d, v), p ? lt([], $, d, v, f, e) : d) : n(d, v) : (d.issues.push({
+      expected: "object",
+      code: "invalid_type",
+      input: $,
+      inst: e
+    }), d);
+  };
+});
+function Ie(e, t, n, r) {
+  for (const i of e)
+    if (i.issues.length === 0)
+      return t.value = i.value, t;
+  const o = e.filter((i) => !j(i));
+  return o.length === 1 ? (t.value = o[0].value, o[0]) : (t.issues.push({
+    code: "invalid_union",
+    input: t.value,
+    inst: n,
+    errors: e.map((i) => i.issues.map((s) => R(s, r, A())))
+  }), t);
+}
+const pt = /* @__PURE__ */ c("$ZodUnion", (e, t) => {
+  y.init(e, t), m(e._zod, "optin", () => t.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0), m(e._zod, "optout", () => t.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0), m(e._zod, "values", () => {
+    if (t.options.every((o) => o._zod.values))
+      return new Set(t.options.flatMap((o) => Array.from(o._zod.values)));
+  }), m(e._zod, "pattern", () => {
+    if (t.options.every((o) => o._zod.pattern)) {
+      const o = t.options.map((i) => i._zod.pattern);
+      return new RegExp(`^(${o.map((i) => me(i.source)).join("|")})$`);
+    }
+  });
+  const n = t.options.length === 1, r = t.options[0]._zod.run;
+  e._zod.parse = (o, i) => {
+    if (n)
+      return r(o, i);
+    let s = !1;
+    const a = [];
+    for (const u of t.options) {
+      const l = u._zod.run({
+        value: o.value,
+        issues: []
+      }, i);
+      if (l instanceof Promise)
+        a.push(l), s = !0;
+      else {
+        if (l.issues.length === 0)
+          return l;
+        a.push(l);
+      }
+    }
+    return s ? Promise.all(a).then((u) => Ie(u, o, e, i)) : Ie(a, o, e, i);
+  };
+}), Ar = /* @__PURE__ */ c("$ZodDiscriminatedUnion", (e, t) => {
+  t.inclusive = !1, pt.init(e, t);
+  const n = e._zod.parse;
+  m(e._zod, "propValues", () => {
+    const o = {};
+    for (const i of t.options) {
+      const s = i._zod.propValues;
+      if (!s || Object.keys(s).length === 0)
+        throw new Error(`Invalid discriminated union option at index "${t.options.indexOf(i)}"`);
+      for (const [a, u] of Object.entries(s)) {
+        o[a] || (o[a] = /* @__PURE__ */ new Set());
+        for (const l of u)
+          o[a].add(l);
+      }
+    }
+    return o;
+  });
+  const r = ee(() => {
+    const o = t.options, i = /* @__PURE__ */ new Map();
+    for (const s of o) {
+      const a = s._zod.propValues?.[t.discriminator];
+      if (!a || a.size === 0)
+        throw new Error(`Invalid discriminated union option at index "${t.options.indexOf(s)}"`);
+      for (const u of a) {
+        if (i.has(u))
+          throw new Error(`Duplicate discriminator value "${String(u)}"`);
+        i.set(u, s);
+      }
+    }
+    return i;
+  });
+  e._zod.parse = (o, i) => {
+    const s = o.value;
+    if (!J(s))
+      return o.issues.push({
+        code: "invalid_type",
+        expected: "object",
+        input: s,
+        inst: e
+      }), o;
+    const a = r.value.get(s?.[t.discriminator]);
+    return a ? a._zod.run(o, i) : t.unionFallback ? n(o, i) : (o.issues.push({
+      code: "invalid_union",
+      errors: [],
+      note: "No matching discriminator",
+      discriminator: t.discriminator,
+      input: s,
+      path: [t.discriminator],
+      inst: e
+    }), o);
+  };
+}), Rr = /* @__PURE__ */ c("$ZodIntersection", (e, t) => {
+  y.init(e, t), e._zod.parse = (n, r) => {
+    const o = n.value, i = t.left._zod.run({ value: o, issues: [] }, r), s = t.right._zod.run({ value: o, issues: [] }, r);
+    return i instanceof Promise || s instanceof Promise ? Promise.all([i, s]).then(([u, l]) => Ee(n, u, l)) : Ee(n, i, s);
+  };
+});
+function pe(e, t) {
+  if (e === t)
+    return { valid: !0, data: e };
+  if (e instanceof Date && t instanceof Date && +e == +t)
+    return { valid: !0, data: e };
+  if (V(e) && V(t)) {
+    const n = Object.keys(t), r = Object.keys(e).filter((i) => n.indexOf(i) !== -1), o = { ...e, ...t };
+    for (const i of r) {
+      const s = pe(e[i], t[i]);
+      if (!s.valid)
+        return {
+          valid: !1,
+          mergeErrorPath: [i, ...s.mergeErrorPath]
+        };
+      o[i] = s.data;
+    }
+    return { valid: !0, data: o };
+  }
+  if (Array.isArray(e) && Array.isArray(t)) {
+    if (e.length !== t.length)
+      return { valid: !1, mergeErrorPath: [] };
+    const n = [];
+    for (let r = 0; r < e.length; r++) {
+      const o = e[r], i = t[r], s = pe(o, i);
+      if (!s.valid)
+        return {
+          valid: !1,
+          mergeErrorPath: [r, ...s.mergeErrorPath]
+        };
+      n.push(s.data);
+    }
+    return { valid: !0, data: n };
+  }
+  return { valid: !1, mergeErrorPath: [] };
+}
+function Ee(e, t, n) {
+  if (t.issues.length && e.issues.push(...t.issues), n.issues.length && e.issues.push(...n.issues), j(e))
+    return e;
+  const r = pe(t.value, n.value);
+  if (!r.valid)
+    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(r.mergeErrorPath)}`);
+  return e.value = r.data, e;
+}
+const Cr = /* @__PURE__ */ c("$ZodEnum", (e, t) => {
+  y.init(e, t);
+  const n = Ke(t.entries), r = new Set(n);
+  e._zod.values = r, e._zod.pattern = new RegExp(`^(${n.filter((o) => Kt.has(typeof o)).map((o) => typeof o == "string" ? L(o) : o.toString()).join("|")})$`), e._zod.parse = (o, i) => {
+    const s = o.value;
+    return r.has(s) || o.issues.push({
+      code: "invalid_value",
+      values: n,
+      input: s,
+      inst: e
+    }), o;
+  };
+}), xr = /* @__PURE__ */ c("$ZodLiteral", (e, t) => {
+  if (y.init(e, t), t.values.length === 0)
+    throw new Error("Cannot create literal schema with no valid values");
+  const n = new Set(t.values);
+  e._zod.values = n, e._zod.pattern = new RegExp(`^(${t.values.map((r) => typeof r == "string" ? L(r) : r ? L(r.toString()) : String(r)).join("|")})$`), e._zod.parse = (r, o) => {
+    const i = r.value;
+    return n.has(i) || r.issues.push({
+      code: "invalid_value",
+      values: t.values,
+      input: i,
+      inst: e
+    }), r;
+  };
+}), jr = /* @__PURE__ */ c("$ZodTransform", (e, t) => {
+  y.init(e, t), e._zod.parse = (n, r) => {
+    if (r.direction === "backward")
+      throw new We(e.constructor.name);
+    const o = t.transform(n.value, n);
+    if (r.async)
+      return (o instanceof Promise ? o : Promise.resolve(o)).then((s) => (n.value = s, n));
+    if (o instanceof Promise)
+      throw new D();
+    return n.value = o, n;
+  };
+});
+function Se(e, t) {
+  return e.issues.length && t === void 0 ? { issues: [], value: void 0 } : e;
+}
+const Dr = /* @__PURE__ */ c("$ZodOptional", (e, t) => {
+  y.init(e, t), e._zod.optin = "optional", e._zod.optout = "optional", m(e._zod, "values", () => t.innerType._zod.values ? /* @__PURE__ */ new Set([...t.innerType._zod.values, void 0]) : void 0), m(e._zod, "pattern", () => {
+    const n = t.innerType._zod.pattern;
+    return n ? new RegExp(`^(${me(n.source)})?$`) : void 0;
+  }), e._zod.parse = (n, r) => {
+    if (t.innerType._zod.optin === "optional") {
+      const o = t.innerType._zod.run(n, r);
+      return o instanceof Promise ? o.then((i) => Se(i, n.value)) : Se(o, n.value);
+    }
+    return n.value === void 0 ? n : t.innerType._zod.run(n, r);
+  };
+}), Lr = /* @__PURE__ */ c("$ZodNullable", (e, t) => {
+  y.init(e, t), m(e._zod, "optin", () => t.innerType._zod.optin), m(e._zod, "optout", () => t.innerType._zod.optout), m(e._zod, "pattern", () => {
+    const n = t.innerType._zod.pattern;
+    return n ? new RegExp(`^(${me(n.source)}|null)$`) : void 0;
+  }), m(e._zod, "values", () => t.innerType._zod.values ? /* @__PURE__ */ new Set([...t.innerType._zod.values, null]) : void 0), e._zod.parse = (n, r) => n.value === null ? n : t.innerType._zod.run(n, r);
+}), Fr = /* @__PURE__ */ c("$ZodDefault", (e, t) => {
+  y.init(e, t), e._zod.optin = "optional", m(e._zod, "values", () => t.innerType._zod.values), e._zod.parse = (n, r) => {
+    if (r.direction === "backward")
+      return t.innerType._zod.run(n, r);
+    if (n.value === void 0)
+      return n.value = t.defaultValue, n;
+    const o = t.innerType._zod.run(n, r);
+    return o instanceof Promise ? o.then((i) => Oe(i, t)) : Oe(o, t);
+  };
+});
+function Oe(e, t) {
+  return e.value === void 0 && (e.value = t.defaultValue), e;
+}
+const Mr = /* @__PURE__ */ c("$ZodPrefault", (e, t) => {
+  y.init(e, t), e._zod.optin = "optional", m(e._zod, "values", () => t.innerType._zod.values), e._zod.parse = (n, r) => (r.direction === "backward" || n.value === void 0 && (n.value = t.defaultValue), t.innerType._zod.run(n, r));
+}), Ur = /* @__PURE__ */ c("$ZodNonOptional", (e, t) => {
+  y.init(e, t), m(e._zod, "values", () => {
+    const n = t.innerType._zod.values;
+    return n ? new Set([...n].filter((r) => r !== void 0)) : void 0;
+  }), e._zod.parse = (n, r) => {
+    const o = t.innerType._zod.run(n, r);
+    return o instanceof Promise ? o.then((i) => Pe(i, e)) : Pe(o, e);
+  };
+});
+function Pe(e, t) {
+  return !e.issues.length && e.value === void 0 && e.issues.push({
+    code: "invalid_type",
+    expected: "nonoptional",
+    input: e.value,
+    inst: t
+  }), e;
+}
+const Jr = /* @__PURE__ */ c("$ZodCatch", (e, t) => {
+  y.init(e, t), m(e._zod, "optin", () => t.innerType._zod.optin), m(e._zod, "optout", () => t.innerType._zod.optout), m(e._zod, "values", () => t.innerType._zod.values), e._zod.parse = (n, r) => {
+    if (r.direction === "backward")
+      return t.innerType._zod.run(n, r);
+    const o = t.innerType._zod.run(n, r);
+    return o instanceof Promise ? o.then((i) => (n.value = i.value, i.issues.length && (n.value = t.catchValue({
+      ...n,
+      error: {
+        issues: i.issues.map((s) => R(s, r, A()))
+      },
+      input: n.value
+    }), n.issues = []), n)) : (n.value = o.value, o.issues.length && (n.value = t.catchValue({
+      ...n,
+      error: {
+        issues: o.issues.map((i) => R(i, r, A()))
+      },
+      input: n.value
+    }), n.issues = []), n);
+  };
+}), Vr = /* @__PURE__ */ c("$ZodPipe", (e, t) => {
+  y.init(e, t), m(e._zod, "values", () => t.in._zod.values), m(e._zod, "optin", () => t.in._zod.optin), m(e._zod, "optout", () => t.out._zod.optout), m(e._zod, "propValues", () => t.in._zod.propValues), e._zod.parse = (n, r) => {
+    if (r.direction === "backward") {
+      const i = t.out._zod.run(n, r);
+      return i instanceof Promise ? i.then((s) => B(s, t.in, r)) : B(i, t.in, r);
+    }
+    const o = t.in._zod.run(n, r);
+    return o instanceof Promise ? o.then((i) => B(i, t.out, r)) : B(o, t.out, r);
+  };
+});
+function B(e, t, n) {
+  return e.issues.length ? (e.aborted = !0, e) : t._zod.run({ value: e.value, issues: e.issues }, n);
+}
+const Gr = /* @__PURE__ */ c("$ZodReadonly", (e, t) => {
+  y.init(e, t), m(e._zod, "propValues", () => t.innerType._zod.propValues), m(e._zod, "values", () => t.innerType._zod.values), m(e._zod, "optin", () => t.innerType?._zod?.optin), m(e._zod, "optout", () => t.innerType?._zod?.optout), e._zod.parse = (n, r) => {
+    if (r.direction === "backward")
+      return t.innerType._zod.run(n, r);
+    const o = t.innerType._zod.run(n, r);
+    return o instanceof Promise ? o.then(Ne) : Ne(o);
+  };
+});
+function Ne(e) {
+  return e.value = Object.freeze(e.value), e;
+}
+const Wr = /* @__PURE__ */ c("$ZodCustom", (e, t) => {
+  z.init(e, t), y.init(e, t), e._zod.parse = (n, r) => n, e._zod.check = (n) => {
+    const r = n.value, o = t.fn(r);
+    if (o instanceof Promise)
+      return o.then((i) => Ae(i, n, r, e));
+    Ae(o, n, r, e);
+  };
+});
+function Ae(e, t, n, r) {
+  if (!e) {
+    const o = {
+      code: "custom",
+      input: n,
+      inst: r,
+      // incorporates params.error into issue reporting
+      path: [...r._zod.def.path ?? []],
+      // incorporates params.error into issue reporting
+      continue: !r._zod.def.abort
+      // params: inst._zod.def.params,
+    };
+    r._zod.def.params && (o.params = r._zod.def.params), t.issues.push(G(o));
+  }
+}
+var Re;
+class Br {
+  constructor() {
+    this._map = /* @__PURE__ */ new WeakMap(), this._idmap = /* @__PURE__ */ new Map();
+  }
+  add(t, ...n) {
+    const r = n[0];
+    if (this._map.set(t, r), r && typeof r == "object" && "id" in r) {
+      if (this._idmap.has(r.id))
+        throw new Error(`ID ${r.id} already exists in the registry`);
+      this._idmap.set(r.id, t);
+    }
+    return this;
+  }
+  clear() {
+    return this._map = /* @__PURE__ */ new WeakMap(), this._idmap = /* @__PURE__ */ new Map(), this;
+  }
+  remove(t) {
+    const n = this._map.get(t);
+    return n && typeof n == "object" && "id" in n && this._idmap.delete(n.id), this._map.delete(t), this;
+  }
+  get(t) {
+    const n = t._zod.parent;
+    if (n) {
+      const r = { ...this.get(n) ?? {} };
+      delete r.id;
+      const o = { ...r, ...this._map.get(t) };
+      return Object.keys(o).length ? o : void 0;
+    }
+    return this._map.get(t);
+  }
+  has(t) {
+    return this._map.has(t);
+  }
+}
+function Kr() {
+  return new Br();
+}
+(Re = globalThis).__zod_globalRegistry ?? (Re.__zod_globalRegistry = Kr());
+const U = globalThis.__zod_globalRegistry;
+function qr(e, t) {
+  return new e({
+    type: "string",
+    ...h(t)
+  });
+}
+function Xr(e, t) {
+  return new e({
+    type: "string",
+    format: "email",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function Ce(e, t) {
+  return new e({
+    type: "string",
+    format: "guid",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function Yr(e, t) {
+  return new e({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function Hr(e, t) {
+  return new e({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: !1,
+    version: "v4",
+    ...h(t)
+  });
+}
+function Qr(e, t) {
+  return new e({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: !1,
+    version: "v6",
+    ...h(t)
+  });
+}
+function eo(e, t) {
+  return new e({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: !1,
+    version: "v7",
+    ...h(t)
+  });
+}
+function to(e, t) {
+  return new e({
+    type: "string",
+    format: "url",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function no(e, t) {
+  return new e({
+    type: "string",
+    format: "emoji",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function ro(e, t) {
+  return new e({
+    type: "string",
+    format: "nanoid",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function oo(e, t) {
+  return new e({
+    type: "string",
+    format: "cuid",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function io(e, t) {
+  return new e({
+    type: "string",
+    format: "cuid2",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function so(e, t) {
+  return new e({
+    type: "string",
+    format: "ulid",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function ao(e, t) {
+  return new e({
+    type: "string",
+    format: "xid",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function co(e, t) {
+  return new e({
+    type: "string",
+    format: "ksuid",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function uo(e, t) {
+  return new e({
+    type: "string",
+    format: "ipv4",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function lo(e, t) {
+  return new e({
+    type: "string",
+    format: "ipv6",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function po(e, t) {
+  return new e({
+    type: "string",
+    format: "cidrv4",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function ho(e, t) {
+  return new e({
+    type: "string",
+    format: "cidrv6",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function fo(e, t) {
+  return new e({
+    type: "string",
+    format: "base64",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function mo(e, t) {
+  return new e({
+    type: "string",
+    format: "base64url",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function go(e, t) {
+  return new e({
+    type: "string",
+    format: "e164",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function vo(e, t) {
+  return new e({
+    type: "string",
+    format: "jwt",
+    check: "string_format",
+    abort: !1,
+    ...h(t)
+  });
+}
+function _o(e, t) {
+  return new e({
+    type: "string",
+    format: "datetime",
+    check: "string_format",
+    offset: !1,
+    local: !1,
+    precision: null,
+    ...h(t)
+  });
+}
+function yo(e, t) {
+  return new e({
+    type: "string",
+    format: "date",
+    check: "string_format",
+    ...h(t)
+  });
+}
+function ko(e, t) {
+  return new e({
+    type: "string",
+    format: "time",
+    check: "string_format",
+    precision: null,
+    ...h(t)
+  });
+}
+function wo(e, t) {
+  return new e({
+    type: "string",
+    format: "duration",
+    check: "string_format",
+    ...h(t)
+  });
+}
+function bo(e, t) {
+  return new e({
+    type: "number",
+    checks: [],
+    ...h(t)
+  });
+}
+function zo(e, t) {
+  return new e({
+    type: "number",
+    check: "number_format",
+    abort: !1,
+    format: "safeint",
+    ...h(t)
+  });
+}
+function $o(e) {
+  return new e({
+    type: "unknown"
+  });
+}
+function To(e, t) {
+  return new e({
+    type: "never",
+    ...h(t)
+  });
+}
+function xe(e, t) {
+  return new it({
+    check: "less_than",
+    ...h(t),
+    value: e,
+    inclusive: !1
+  });
+}
+function se(e, t) {
+  return new it({
+    check: "less_than",
+    ...h(t),
+    value: e,
+    inclusive: !0
+  });
+}
+function je(e, t) {
+  return new st({
+    check: "greater_than",
+    ...h(t),
+    value: e,
+    inclusive: !1
+  });
+}
+function ae(e, t) {
+  return new st({
+    check: "greater_than",
+    ...h(t),
+    value: e,
+    inclusive: !0
+  });
+}
+function De(e, t) {
+  return new Un({
+    check: "multiple_of",
+    ...h(t),
+    value: e
+  });
+}
+function ht(e, t) {
+  return new Vn({
+    check: "max_length",
+    ...h(t),
+    maximum: e
+  });
+}
+function X(e, t) {
+  return new Gn({
+    check: "min_length",
+    ...h(t),
+    minimum: e
+  });
+}
+function ft(e, t) {
+  return new Wn({
+    check: "length_equals",
+    ...h(t),
+    length: e
+  });
+}
+function Zo(e, t) {
+  return new Bn({
+    check: "string_format",
+    format: "regex",
+    ...h(t),
+    pattern: e
+  });
+}
+function Io(e) {
+  return new Kn({
+    check: "string_format",
+    format: "lowercase",
+    ...h(e)
+  });
+}
+function Eo(e) {
+  return new qn({
+    check: "string_format",
+    format: "uppercase",
+    ...h(e)
+  });
+}
+function So(e, t) {
+  return new Xn({
+    check: "string_format",
+    format: "includes",
+    ...h(t),
+    includes: e
+  });
+}
+function Oo(e, t) {
+  return new Yn({
+    check: "string_format",
+    format: "starts_with",
+    ...h(t),
+    prefix: e
+  });
+}
+function Po(e, t) {
+  return new Hn({
+    check: "string_format",
+    format: "ends_with",
+    ...h(t),
+    suffix: e
+  });
+}
+function F(e) {
+  return new Qn({
+    check: "overwrite",
+    tx: e
+  });
+}
+function No(e) {
+  return F((t) => t.normalize(e));
+}
+function Ao() {
+  return F((e) => e.trim());
+}
+function Ro() {
+  return F((e) => e.toLowerCase());
+}
+function Co() {
+  return F((e) => e.toUpperCase());
+}
+function xo() {
+  return F((e) => Wt(e));
+}
+function jo(e, t, n) {
+  return new e({
+    type: "array",
+    element: t,
+    // get element() {
+    //   return element;
+    // },
+    ...h(n)
+  });
+}
+function Do(e, t, n) {
+  return new e({
+    type: "custom",
+    check: "custom",
+    fn: t,
+    ...h(n)
+  });
+}
+function Lo(e) {
+  const t = Fo((n) => (n.addIssue = (r) => {
+    if (typeof r == "string")
+      n.issues.push(G(r, n.value, t._zod.def));
+    else {
+      const o = r;
+      o.fatal && (o.continue = !1), o.code ?? (o.code = "custom"), o.input ?? (o.input = n.value), o.inst ?? (o.inst = t), o.continue ?? (o.continue = !t._zod.def.abort), n.issues.push(G(o));
+    }
+  }, e(n.value, n)));
+  return t;
+}
+function Fo(e, t) {
+  const n = new z({
+    check: "custom",
+    ...h(t)
+  });
+  return n._zod.check = e, n;
+}
+function dt(e) {
+  let t = e?.target ?? "draft-2020-12";
+  return t === "draft-4" && (t = "draft-04"), t === "draft-7" && (t = "draft-07"), {
+    processors: e.processors ?? {},
+    metadataRegistry: e?.metadata ?? U,
+    target: t,
+    unrepresentable: e?.unrepresentable ?? "throw",
+    override: e?.override ?? (() => {
+    }),
+    io: e?.io ?? "output",
+    counter: 0,
+    seen: /* @__PURE__ */ new Map(),
+    cycles: e?.cycles ?? "ref",
+    reused: e?.reused ?? "inline",
+    external: e?.external ?? void 0
+  };
+}
+function w(e, t, n = { path: [], schemaPath: [] }) {
+  var r;
+  const o = e._zod.def, i = t.seen.get(e);
+  if (i)
+    return i.count++, n.schemaPath.includes(e) && (i.cycle = n.path), i.schema;
+  const s = { schema: {}, count: 1, cycle: void 0, path: n.path };
+  t.seen.set(e, s);
+  const a = e._zod.toJSONSchema?.();
+  if (a)
+    s.schema = a;
+  else {
+    const p = {
+      ...n,
+      schemaPath: [...n.schemaPath, e],
+      path: n.path
+    }, f = e._zod.parent;
+    if (f)
+      s.ref = f, w(f, t, p), t.seen.get(f).isParent = !0;
+    else if (e._zod.processJSONSchema)
+      e._zod.processJSONSchema(t, s.schema, p);
+    else {
+      const d = s.schema, v = t.processors[o.type];
+      if (!v)
+        throw new Error(`[toJSONSchema]: Non-representable type encountered: ${o.type}`);
+      v(e, t, d, p);
+    }
+  }
+  const u = t.metadataRegistry.get(e);
+  return u && Object.assign(s.schema, u), t.io === "input" && b(e) && (delete s.schema.examples, delete s.schema.default), t.io === "input" && s.schema._prefault && ((r = s.schema).default ?? (r.default = s.schema._prefault)), delete s.schema._prefault, t.seen.get(e).schema;
+}
+function mt(e, t) {
+  const n = e.seen.get(t);
+  if (!n)
+    throw new Error("Unprocessed schema. This is a bug in Zod.");
+  const r = (i) => {
+    const s = e.target === "draft-2020-12" ? "$defs" : "definitions";
+    if (e.external) {
+      const p = e.external.registry.get(i[0])?.id, f = e.external.uri ?? ((v) => v);
+      if (p)
+        return { ref: f(p) };
+      const d = i[1].defId ?? i[1].schema.id ?? `schema${e.counter++}`;
+      return i[1].defId = d, { defId: d, ref: `${f("__shared")}#/${s}/${d}` };
+    }
+    if (i[1] === n)
+      return { ref: "#" };
+    const u = `#/${s}/`, l = i[1].schema.id ?? `__schema${e.counter++}`;
+    return { defId: l, ref: u + l };
+  }, o = (i) => {
+    if (i[1].schema.$ref)
+      return;
+    const s = i[1], { ref: a, defId: u } = r(i);
+    s.def = { ...s.schema }, u && (s.defId = u);
+    const l = s.schema;
+    for (const p in l)
+      delete l[p];
+    l.$ref = a;
+  };
+  if (e.cycles === "throw")
+    for (const i of e.seen.entries()) {
+      const s = i[1];
+      if (s.cycle)
+        throw new Error(`Cycle detected: #/${s.cycle?.join("/")}/<root>
+
+Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
+    }
+  for (const i of e.seen.entries()) {
+    const s = i[1];
+    if (t === i[0]) {
+      o(i);
+      continue;
+    }
+    if (e.external) {
+      const u = e.external.registry.get(i[0])?.id;
+      if (t !== i[0] && u) {
+        o(i);
+        continue;
+      }
+    }
+    if (e.metadataRegistry.get(i[0])?.id) {
+      o(i);
+      continue;
+    }
+    if (s.cycle) {
+      o(i);
+      continue;
+    }
+    if (s.count > 1 && e.reused === "ref") {
+      o(i);
+      continue;
+    }
+  }
+}
+function gt(e, t) {
+  const n = e.seen.get(t);
+  if (!n)
+    throw new Error("Unprocessed schema. This is a bug in Zod.");
+  const r = (s) => {
+    const a = e.seen.get(s), u = a.def ?? a.schema, l = { ...u };
+    if (a.ref === null)
+      return;
+    const p = a.ref;
+    if (a.ref = null, p) {
+      r(p);
+      const f = e.seen.get(p).schema;
+      f.$ref && (e.target === "draft-07" || e.target === "draft-04" || e.target === "openapi-3.0") ? (u.allOf = u.allOf ?? [], u.allOf.push(f)) : (Object.assign(u, f), Object.assign(u, l));
+    }
+    a.isParent || e.override({
+      zodSchema: s,
+      jsonSchema: u,
+      path: a.path ?? []
+    });
+  };
+  for (const s of [...e.seen.entries()].reverse())
+    r(s[0]);
+  const o = {};
+  if (e.target === "draft-2020-12" ? o.$schema = "https://json-schema.org/draft/2020-12/schema" : e.target === "draft-07" ? o.$schema = "http://json-schema.org/draft-07/schema#" : e.target === "draft-04" ? o.$schema = "http://json-schema.org/draft-04/schema#" : e.target, e.external?.uri) {
+    const s = e.external.registry.get(t)?.id;
+    if (!s)
+      throw new Error("Schema is missing an `id` property");
+    o.$id = e.external.uri(s);
+  }
+  Object.assign(o, n.def ?? n.schema);
+  const i = e.external?.defs ?? {};
+  for (const s of e.seen.entries()) {
+    const a = s[1];
+    a.def && a.defId && (i[a.defId] = a.def);
+  }
+  e.external || Object.keys(i).length > 0 && (e.target === "draft-2020-12" ? o.$defs = i : o.definitions = i);
+  try {
+    const s = JSON.parse(JSON.stringify(o));
+    return Object.defineProperty(s, "~standard", {
+      value: {
+        ...t["~standard"],
+        jsonSchema: {
+          input: Y(t, "input"),
+          output: Y(t, "output")
+        }
+      },
+      enumerable: !1,
+      writable: !1
+    }), s;
+  } catch {
+    throw new Error("Error converting schema to JSON.");
+  }
+}
+function b(e, t) {
+  const n = t ?? { seen: /* @__PURE__ */ new Set() };
+  if (n.seen.has(e))
+    return !1;
+  n.seen.add(e);
+  const r = e._zod.def;
+  if (r.type === "transform")
+    return !0;
+  if (r.type === "array")
+    return b(r.element, n);
+  if (r.type === "set")
+    return b(r.valueType, n);
+  if (r.type === "lazy")
+    return b(r.getter(), n);
+  if (r.type === "promise" || r.type === "optional" || r.type === "nonoptional" || r.type === "nullable" || r.type === "readonly" || r.type === "default" || r.type === "prefault")
+    return b(r.innerType, n);
+  if (r.type === "intersection")
+    return b(r.left, n) || b(r.right, n);
+  if (r.type === "record" || r.type === "map")
+    return b(r.keyType, n) || b(r.valueType, n);
+  if (r.type === "pipe")
+    return b(r.in, n) || b(r.out, n);
+  if (r.type === "object") {
+    for (const o in r.shape)
+      if (b(r.shape[o], n))
+        return !0;
+    return !1;
+  }
+  if (r.type === "union") {
+    for (const o of r.options)
+      if (b(o, n))
+        return !0;
+    return !1;
+  }
+  if (r.type === "tuple") {
+    for (const o of r.items)
+      if (b(o, n))
+        return !0;
+    return !!(r.rest && b(r.rest, n));
+  }
+  return !1;
+}
+const Mo = (e, t = {}) => (n) => {
+  const r = dt({ ...n, processors: t });
+  return w(e, r), mt(r, e), gt(r, e);
+}, Y = (e, t) => (n) => {
+  const { libraryOptions: r, target: o } = n ?? {}, i = dt({ ...r ?? {}, target: o, io: t, processors: {} });
+  return w(e, i), mt(i, e), gt(i, e);
+}, Uo = {
+  guid: "uuid",
+  url: "uri",
+  datetime: "date-time",
+  json_string: "json-string",
+  regex: ""
+  // do not set
+}, Jo = (e, t, n, r) => {
+  const o = n;
+  o.type = "string";
+  const { minimum: i, maximum: s, format: a, patterns: u, contentEncoding: l } = e._zod.bag;
+  if (typeof i == "number" && (o.minLength = i), typeof s == "number" && (o.maxLength = s), a && (o.format = Uo[a] ?? a, o.format === "" && delete o.format), l && (o.contentEncoding = l), u && u.size > 0) {
+    const p = [...u];
+    p.length === 1 ? o.pattern = p[0].source : p.length > 1 && (o.allOf = [
+      ...p.map((f) => ({
+        ...t.target === "draft-07" || t.target === "draft-04" || t.target === "openapi-3.0" ? { type: "string" } : {},
+        pattern: f.source
+      }))
+    ]);
+  }
+}, Vo = (e, t, n, r) => {
+  const o = n, { minimum: i, maximum: s, format: a, multipleOf: u, exclusiveMaximum: l, exclusiveMinimum: p } = e._zod.bag;
+  typeof a == "string" && a.includes("int") ? o.type = "integer" : o.type = "number", typeof p == "number" && (t.target === "draft-04" || t.target === "openapi-3.0" ? (o.minimum = p, o.exclusiveMinimum = !0) : o.exclusiveMinimum = p), typeof i == "number" && (o.minimum = i, typeof p == "number" && t.target !== "draft-04" && (p >= i ? delete o.minimum : delete o.exclusiveMinimum)), typeof l == "number" && (t.target === "draft-04" || t.target === "openapi-3.0" ? (o.maximum = l, o.exclusiveMaximum = !0) : o.exclusiveMaximum = l), typeof s == "number" && (o.maximum = s, typeof l == "number" && t.target !== "draft-04" && (l <= s ? delete o.maximum : delete o.exclusiveMaximum)), typeof u == "number" && (o.multipleOf = u);
+}, Go = (e, t, n, r) => {
+  n.not = {};
+}, Wo = (e, t, n, r) => {
+}, Bo = (e, t, n, r) => {
+  const o = e._zod.def, i = Ke(o.entries);
+  i.every((s) => typeof s == "number") && (n.type = "number"), i.every((s) => typeof s == "string") && (n.type = "string"), n.enum = i;
+}, Ko = (e, t, n, r) => {
+  const o = e._zod.def, i = [];
+  for (const s of o.values)
+    if (s === void 0) {
+      if (t.unrepresentable === "throw")
+        throw new Error("Literal `undefined` cannot be represented in JSON Schema");
+    } else if (typeof s == "bigint") {
+      if (t.unrepresentable === "throw")
+        throw new Error("BigInt literals cannot be represented in JSON Schema");
+      i.push(Number(s));
+    } else
+      i.push(s);
+  if (i.length !== 0) if (i.length === 1) {
+    const s = i[0];
+    n.type = s === null ? "null" : typeof s, t.target === "draft-04" || t.target === "openapi-3.0" ? n.enum = [s] : n.const = s;
+  } else
+    i.every((s) => typeof s == "number") && (n.type = "number"), i.every((s) => typeof s == "string") && (n.type = "string"), i.every((s) => typeof s == "boolean") && (n.type = "boolean"), i.every((s) => s === null) && (n.type = "null"), n.enum = i;
+}, qo = (e, t, n, r) => {
+  if (t.unrepresentable === "throw")
+    throw new Error("Custom types cannot be represented in JSON Schema");
+}, Xo = (e, t, n, r) => {
+  if (t.unrepresentable === "throw")
+    throw new Error("Transforms cannot be represented in JSON Schema");
+}, Yo = (e, t, n, r) => {
+  const o = n, i = e._zod.def, { minimum: s, maximum: a } = e._zod.bag;
+  typeof s == "number" && (o.minItems = s), typeof a == "number" && (o.maxItems = a), o.type = "array", o.items = w(i.element, t, { ...r, path: [...r.path, "items"] });
+}, Ho = (e, t, n, r) => {
+  const o = n, i = e._zod.def;
+  o.type = "object", o.properties = {};
+  const s = i.shape;
+  for (const l in s)
+    o.properties[l] = w(s[l], t, {
+      ...r,
+      path: [...r.path, "properties", l]
+    });
+  const a = new Set(Object.keys(s)), u = new Set([...a].filter((l) => {
+    const p = i.shape[l]._zod;
+    return t.io === "input" ? p.optin === void 0 : p.optout === void 0;
+  }));
+  u.size > 0 && (o.required = Array.from(u)), i.catchall?._zod.def.type === "never" ? o.additionalProperties = !1 : i.catchall ? i.catchall && (o.additionalProperties = w(i.catchall, t, {
+    ...r,
+    path: [...r.path, "additionalProperties"]
+  })) : t.io === "output" && (o.additionalProperties = !1);
+}, Qo = (e, t, n, r) => {
+  const o = e._zod.def, i = o.inclusive === !1, s = o.options.map((a, u) => w(a, t, {
+    ...r,
+    path: [...r.path, i ? "oneOf" : "anyOf", u]
+  }));
+  i ? n.oneOf = s : n.anyOf = s;
+}, ei = (e, t, n, r) => {
+  const o = e._zod.def, i = w(o.left, t, {
+    ...r,
+    path: [...r.path, "allOf", 0]
+  }), s = w(o.right, t, {
+    ...r,
+    path: [...r.path, "allOf", 1]
+  }), a = (l) => "allOf" in l && Object.keys(l).length === 1, u = [
+    ...a(i) ? i.allOf : [i],
+    ...a(s) ? s.allOf : [s]
+  ];
+  n.allOf = u;
+}, ti = (e, t, n, r) => {
+  const o = e._zod.def, i = w(o.innerType, t, r), s = t.seen.get(e);
+  t.target === "openapi-3.0" ? (s.ref = o.innerType, n.nullable = !0) : n.anyOf = [i, { type: "null" }];
+}, ni = (e, t, n, r) => {
+  const o = e._zod.def;
+  w(o.innerType, t, r);
+  const i = t.seen.get(e);
+  i.ref = o.innerType;
+}, ri = (e, t, n, r) => {
+  const o = e._zod.def;
+  w(o.innerType, t, r);
+  const i = t.seen.get(e);
+  i.ref = o.innerType, n.default = JSON.parse(JSON.stringify(o.defaultValue));
+}, oi = (e, t, n, r) => {
+  const o = e._zod.def;
+  w(o.innerType, t, r);
+  const i = t.seen.get(e);
+  i.ref = o.innerType, t.io === "input" && (n._prefault = JSON.parse(JSON.stringify(o.defaultValue)));
+}, ii = (e, t, n, r) => {
+  const o = e._zod.def;
+  w(o.innerType, t, r);
+  const i = t.seen.get(e);
+  i.ref = o.innerType;
+  let s;
+  try {
+    s = o.catchValue(void 0);
+  } catch {
+    throw new Error("Dynamic catch values are not supported in JSON Schema");
+  }
+  n.default = s;
+}, si = (e, t, n, r) => {
+  const o = e._zod.def, i = t.io === "input" ? o.in._zod.def.type === "transform" ? o.out : o.in : o.out;
+  w(i, t, r);
+  const s = t.seen.get(e);
+  s.ref = i;
+}, ai = (e, t, n, r) => {
+  const o = e._zod.def;
+  w(o.innerType, t, r);
+  const i = t.seen.get(e);
+  i.ref = o.innerType, n.readOnly = !0;
+}, ci = (e, t, n, r) => {
+  const o = e._zod.def;
+  w(o.innerType, t, r);
+  const i = t.seen.get(e);
+  i.ref = o.innerType;
+}, ui = /* @__PURE__ */ c("ZodISODateTime", (e, t) => {
+  fr.init(e, t), _.init(e, t);
+});
+function li(e) {
+  return _o(ui, e);
+}
+const pi = /* @__PURE__ */ c("ZodISODate", (e, t) => {
+  dr.init(e, t), _.init(e, t);
+});
+function hi(e) {
+  return yo(pi, e);
+}
+const fi = /* @__PURE__ */ c("ZodISOTime", (e, t) => {
+  mr.init(e, t), _.init(e, t);
+});
+function di(e) {
+  return ko(fi, e);
+}
+const mi = /* @__PURE__ */ c("ZodISODuration", (e, t) => {
+  gr.init(e, t), _.init(e, t);
+});
+function gi(e) {
+  return wo(mi, e);
+}
+const vi = (e, t) => {
+  Qe.init(e, t), e.name = "ZodError", Object.defineProperties(e, {
+    format: {
+      value: (n) => sn(e, n)
+      // enumerable: false,
+    },
+    flatten: {
+      value: (n) => on(e, n)
+      // enumerable: false,
+    },
+    addIssue: {
+      value: (n) => {
+        e.issues.push(n), e.message = JSON.stringify(e.issues, le, 2);
+      }
+      // enumerable: false,
+    },
+    addIssues: {
+      value: (n) => {
+        e.issues.push(...n), e.message = JSON.stringify(e.issues, le, 2);
+      }
+      // enumerable: false,
+    },
+    isEmpty: {
+      get() {
+        return e.issues.length === 0;
+      }
+      // enumerable: false,
+    }
+  });
+}, T = c("ZodError", vi, {
+  Parent: Error
+}), _i = /* @__PURE__ */ ve(T), yi = /* @__PURE__ */ _e(T), ki = /* @__PURE__ */ te(T), wi = /* @__PURE__ */ ne(T), bi = /* @__PURE__ */ un(T), zi = /* @__PURE__ */ ln(T), $i = /* @__PURE__ */ pn(T), Ti = /* @__PURE__ */ hn(T), Zi = /* @__PURE__ */ fn(T), Ii = /* @__PURE__ */ dn(T), Ei = /* @__PURE__ */ mn(T), Si = /* @__PURE__ */ gn(T), k = /* @__PURE__ */ c("ZodType", (e, t) => (y.init(e, t), Object.assign(e["~standard"], {
+  jsonSchema: {
+    input: Y(e, "input"),
+    output: Y(e, "output")
+  }
+}), e.toJSONSchema = Mo(e, {}), e.def = t, e.type = t.type, Object.defineProperty(e, "_def", { value: t }), e.check = (...n) => e.clone(x(t, {
+  checks: [
+    ...t.checks ?? [],
+    ...n.map((r) => typeof r == "function" ? { _zod: { check: r, def: { check: "custom" }, onattach: [] } } : r)
+  ]
+})), e.clone = (n, r) => P(e, n, r), e.brand = () => e, e.register = ((n, r) => (n.add(e, r), e)), e.parse = (n, r) => _i(e, n, r, { callee: e.parse }), e.safeParse = (n, r) => ki(e, n, r), e.parseAsync = async (n, r) => yi(e, n, r, { callee: e.parseAsync }), e.safeParseAsync = async (n, r) => wi(e, n, r), e.spa = e.safeParseAsync, e.encode = (n, r) => bi(e, n, r), e.decode = (n, r) => zi(e, n, r), e.encodeAsync = async (n, r) => $i(e, n, r), e.decodeAsync = async (n, r) => Ti(e, n, r), e.safeEncode = (n, r) => Zi(e, n, r), e.safeDecode = (n, r) => Ii(e, n, r), e.safeEncodeAsync = async (n, r) => Ei(e, n, r), e.safeDecodeAsync = async (n, r) => Si(e, n, r), e.refine = (n, r) => e.check(ks(n, r)), e.superRefine = (n) => e.check(ws(n)), e.overwrite = (n) => e.check(F(n)), e.optional = () => Ue(e), e.nullable = () => Je(e), e.nullish = () => Ue(Je(e)), e.nonoptional = (n) => fs(e, n), e.array = () => N(e), e.or = (n) => ke([e, n]), e.and = (n) => os(e, n), e.transform = (n) => Ve(e, as(n)), e.default = (n) => ls(e, n), e.prefault = (n) => hs(e, n), e.catch = (n) => ms(e, n), e.pipe = (n) => Ve(e, n), e.readonly = () => _s(e), e.describe = (n) => {
+  const r = e.clone();
+  return U.add(r, { description: n }), r;
+}, Object.defineProperty(e, "description", {
+  get() {
+    return U.get(e)?.description;
+  },
+  configurable: !0
+}), e.meta = (...n) => {
+  if (n.length === 0)
+    return U.get(e);
+  const r = e.clone();
+  return U.add(r, n[0]), r;
+}, e.isOptional = () => e.safeParse(void 0).success, e.isNullable = () => e.safeParse(null).success, e)), vt = /* @__PURE__ */ c("_ZodString", (e, t) => {
+  ye.init(e, t), k.init(e, t), e._zod.processJSONSchema = (r, o, i) => Jo(e, r, o);
+  const n = e._zod.bag;
+  e.format = n.format ?? null, e.minLength = n.minimum ?? null, e.maxLength = n.maximum ?? null, e.regex = (...r) => e.check(Zo(...r)), e.includes = (...r) => e.check(So(...r)), e.startsWith = (...r) => e.check(Oo(...r)), e.endsWith = (...r) => e.check(Po(...r)), e.min = (...r) => e.check(X(...r)), e.max = (...r) => e.check(ht(...r)), e.length = (...r) => e.check(ft(...r)), e.nonempty = (...r) => e.check(X(1, ...r)), e.lowercase = (r) => e.check(Io(r)), e.uppercase = (r) => e.check(Eo(r)), e.trim = () => e.check(Ao()), e.normalize = (...r) => e.check(No(...r)), e.toLowerCase = () => e.check(Ro()), e.toUpperCase = () => e.check(Co()), e.slugify = () => e.check(xo());
+}), Oi = /* @__PURE__ */ c("ZodString", (e, t) => {
+  ye.init(e, t), vt.init(e, t), e.email = (n) => e.check(Xr(Pi, n)), e.url = (n) => e.check(to(Ni, n)), e.jwt = (n) => e.check(vo(Bi, n)), e.emoji = (n) => e.check(no(Ai, n)), e.guid = (n) => e.check(Ce(Le, n)), e.uuid = (n) => e.check(Yr(K, n)), e.uuidv4 = (n) => e.check(Hr(K, n)), e.uuidv6 = (n) => e.check(Qr(K, n)), e.uuidv7 = (n) => e.check(eo(K, n)), e.nanoid = (n) => e.check(ro(Ri, n)), e.guid = (n) => e.check(Ce(Le, n)), e.cuid = (n) => e.check(oo(Ci, n)), e.cuid2 = (n) => e.check(io(xi, n)), e.ulid = (n) => e.check(so(ji, n)), e.base64 = (n) => e.check(fo(Vi, n)), e.base64url = (n) => e.check(mo(Gi, n)), e.xid = (n) => e.check(ao(Di, n)), e.ksuid = (n) => e.check(co(Li, n)), e.ipv4 = (n) => e.check(uo(Fi, n)), e.ipv6 = (n) => e.check(lo(Mi, n)), e.cidrv4 = (n) => e.check(po(Ui, n)), e.cidrv6 = (n) => e.check(ho(Ji, n)), e.e164 = (n) => e.check(go(Wi, n)), e.datetime = (n) => e.check(li(n)), e.date = (n) => e.check(hi(n)), e.time = (n) => e.check(di(n)), e.duration = (n) => e.check(gi(n));
+});
+function I(e) {
+  return qr(Oi, e);
+}
+const _ = /* @__PURE__ */ c("ZodStringFormat", (e, t) => {
+  g.init(e, t), vt.init(e, t);
+}), Pi = /* @__PURE__ */ c("ZodEmail", (e, t) => {
+  or.init(e, t), _.init(e, t);
+}), Le = /* @__PURE__ */ c("ZodGUID", (e, t) => {
+  nr.init(e, t), _.init(e, t);
+}), K = /* @__PURE__ */ c("ZodUUID", (e, t) => {
+  rr.init(e, t), _.init(e, t);
+}), Ni = /* @__PURE__ */ c("ZodURL", (e, t) => {
+  ir.init(e, t), _.init(e, t);
+}), Ai = /* @__PURE__ */ c("ZodEmoji", (e, t) => {
+  sr.init(e, t), _.init(e, t);
+}), Ri = /* @__PURE__ */ c("ZodNanoID", (e, t) => {
+  ar.init(e, t), _.init(e, t);
+}), Ci = /* @__PURE__ */ c("ZodCUID", (e, t) => {
+  cr.init(e, t), _.init(e, t);
+}), xi = /* @__PURE__ */ c("ZodCUID2", (e, t) => {
+  ur.init(e, t), _.init(e, t);
+}), ji = /* @__PURE__ */ c("ZodULID", (e, t) => {
+  lr.init(e, t), _.init(e, t);
+}), Di = /* @__PURE__ */ c("ZodXID", (e, t) => {
+  pr.init(e, t), _.init(e, t);
+}), Li = /* @__PURE__ */ c("ZodKSUID", (e, t) => {
+  hr.init(e, t), _.init(e, t);
+}), Fi = /* @__PURE__ */ c("ZodIPv4", (e, t) => {
+  vr.init(e, t), _.init(e, t);
+}), Mi = /* @__PURE__ */ c("ZodIPv6", (e, t) => {
+  _r.init(e, t), _.init(e, t);
+}), Ui = /* @__PURE__ */ c("ZodCIDRv4", (e, t) => {
+  yr.init(e, t), _.init(e, t);
+}), Ji = /* @__PURE__ */ c("ZodCIDRv6", (e, t) => {
+  kr.init(e, t), _.init(e, t);
+}), Vi = /* @__PURE__ */ c("ZodBase64", (e, t) => {
+  wr.init(e, t), _.init(e, t);
+}), Gi = /* @__PURE__ */ c("ZodBase64URL", (e, t) => {
+  zr.init(e, t), _.init(e, t);
+}), Wi = /* @__PURE__ */ c("ZodE164", (e, t) => {
+  $r.init(e, t), _.init(e, t);
+}), Bi = /* @__PURE__ */ c("ZodJWT", (e, t) => {
+  Zr.init(e, t), _.init(e, t);
+}), _t = /* @__PURE__ */ c("ZodNumber", (e, t) => {
+  ct.init(e, t), k.init(e, t), e._zod.processJSONSchema = (r, o, i) => Vo(e, r, o), e.gt = (r, o) => e.check(je(r, o)), e.gte = (r, o) => e.check(ae(r, o)), e.min = (r, o) => e.check(ae(r, o)), e.lt = (r, o) => e.check(xe(r, o)), e.lte = (r, o) => e.check(se(r, o)), e.max = (r, o) => e.check(se(r, o)), e.int = (r) => e.check(Fe(r)), e.safe = (r) => e.check(Fe(r)), e.positive = (r) => e.check(je(0, r)), e.nonnegative = (r) => e.check(ae(0, r)), e.negative = (r) => e.check(xe(0, r)), e.nonpositive = (r) => e.check(se(0, r)), e.multipleOf = (r, o) => e.check(De(r, o)), e.step = (r, o) => e.check(De(r, o)), e.finite = () => e;
+  const n = e._zod.bag;
+  e.minValue = Math.max(n.minimum ?? Number.NEGATIVE_INFINITY, n.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null, e.maxValue = Math.min(n.maximum ?? Number.POSITIVE_INFINITY, n.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null, e.isInt = (n.format ?? "").includes("int") || Number.isSafeInteger(n.multipleOf ?? 0.5), e.isFinite = !0, e.format = n.format ?? null;
+});
+function Ki(e) {
+  return bo(_t, e);
+}
+const qi = /* @__PURE__ */ c("ZodNumberFormat", (e, t) => {
+  Ir.init(e, t), _t.init(e, t);
+});
+function Fe(e) {
+  return zo(qi, e);
+}
+const Xi = /* @__PURE__ */ c("ZodUnknown", (e, t) => {
+  Er.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => Wo();
+});
+function Me() {
+  return $o(Xi);
+}
+const Yi = /* @__PURE__ */ c("ZodNever", (e, t) => {
+  Sr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => Go(e, n, r);
+});
+function Hi(e) {
+  return To(Yi, e);
+}
+const Qi = /* @__PURE__ */ c("ZodArray", (e, t) => {
+  Or.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => Yo(e, n, r, o), e.element = t.element, e.min = (n, r) => e.check(X(n, r)), e.nonempty = (n) => e.check(X(1, n)), e.max = (n, r) => e.check(ht(n, r)), e.length = (n, r) => e.check(ft(n, r)), e.unwrap = () => e.element;
+});
+function N(e, t) {
+  return jo(Qi, e, t);
+}
+const es = /* @__PURE__ */ c("ZodObject", (e, t) => {
+  Nr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => Ho(e, n, r, o), m(e, "shape", () => t.shape), e.keyof = () => kt(Object.keys(e._zod.def.shape)), e.catchall = (n) => e.clone({ ...e._zod.def, catchall: n }), e.passthrough = () => e.clone({ ...e._zod.def, catchall: Me() }), e.loose = () => e.clone({ ...e._zod.def, catchall: Me() }), e.strict = () => e.clone({ ...e._zod.def, catchall: Hi() }), e.strip = () => e.clone({ ...e._zod.def, catchall: void 0 }), e.extend = (n) => Qt(e, n), e.safeExtend = (n) => en(e, n), e.merge = (n) => tn(e, n), e.pick = (n) => Yt(e, n), e.omit = (n) => Ht(e, n), e.partial = (...n) => nn(wt, e, n[0]), e.required = (...n) => rn(bt, e, n[0]);
+});
+function S(e, t) {
+  const n = {
+    type: "object",
+    shape: e ?? {},
+    ...h(t)
+  };
+  return new es(n);
+}
+const yt = /* @__PURE__ */ c("ZodUnion", (e, t) => {
+  pt.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => Qo(e, n, r, o), e.options = t.options;
+});
+function ke(e, t) {
+  return new yt({
+    type: "union",
+    options: e,
+    ...h(t)
+  });
+}
+const ts = /* @__PURE__ */ c("ZodDiscriminatedUnion", (e, t) => {
+  yt.init(e, t), Ar.init(e, t);
+});
+function ns(e, t, n) {
+  return new ts({
+    type: "union",
+    options: t,
+    discriminator: e,
+    ...h(n)
+  });
+}
+const rs = /* @__PURE__ */ c("ZodIntersection", (e, t) => {
+  Rr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => ei(e, n, r, o);
+});
+function os(e, t) {
+  return new rs({
+    type: "intersection",
+    left: e,
+    right: t
+  });
+}
+const he = /* @__PURE__ */ c("ZodEnum", (e, t) => {
+  Cr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (r, o, i) => Bo(e, r, o), e.enum = t.entries, e.options = Object.values(t.entries);
+  const n = new Set(Object.keys(t.entries));
+  e.extract = (r, o) => {
+    const i = {};
+    for (const s of r)
+      if (n.has(s))
+        i[s] = t.entries[s];
+      else
+        throw new Error(`Key ${s} not found in enum`);
+    return new he({
+      ...t,
+      checks: [],
+      ...h(o),
+      entries: i
+    });
+  }, e.exclude = (r, o) => {
+    const i = { ...t.entries };
+    for (const s of r)
+      if (n.has(s))
+        delete i[s];
+      else
+        throw new Error(`Key ${s} not found in enum`);
+    return new he({
+      ...t,
+      checks: [],
+      ...h(o),
+      entries: i
+    });
+  };
+});
+function kt(e, t) {
+  const n = Array.isArray(e) ? Object.fromEntries(e.map((r) => [r, r])) : e;
+  return new he({
+    type: "enum",
+    entries: n,
+    ...h(t)
+  });
+}
+const is = /* @__PURE__ */ c("ZodLiteral", (e, t) => {
+  xr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => Ko(e, n, r), e.values = new Set(t.values), Object.defineProperty(e, "value", {
+    get() {
+      if (t.values.length > 1)
+        throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+      return t.values[0];
+    }
+  });
+});
+function oe(e, t) {
+  return new is({
+    type: "literal",
+    values: Array.isArray(e) ? e : [e],
+    ...h(t)
+  });
+}
+const ss = /* @__PURE__ */ c("ZodTransform", (e, t) => {
+  jr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => Xo(e, n), e._zod.parse = (n, r) => {
+    if (r.direction === "backward")
+      throw new We(e.constructor.name);
+    n.addIssue = (i) => {
+      if (typeof i == "string")
+        n.issues.push(G(i, n.value, t));
+      else {
+        const s = i;
+        s.fatal && (s.continue = !1), s.code ?? (s.code = "custom"), s.input ?? (s.input = n.value), s.inst ?? (s.inst = e), n.issues.push(G(s));
+      }
+    };
+    const o = t.transform(n.value, n);
+    return o instanceof Promise ? o.then((i) => (n.value = i, n)) : (n.value = o, n);
+  };
+});
+function as(e) {
+  return new ss({
+    type: "transform",
+    transform: e
+  });
+}
+const wt = /* @__PURE__ */ c("ZodOptional", (e, t) => {
+  Dr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => ci(e, n, r, o), e.unwrap = () => e._zod.def.innerType;
+});
+function Ue(e) {
+  return new wt({
+    type: "optional",
+    innerType: e
+  });
+}
+const cs = /* @__PURE__ */ c("ZodNullable", (e, t) => {
+  Lr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => ti(e, n, r, o), e.unwrap = () => e._zod.def.innerType;
+});
+function Je(e) {
+  return new cs({
+    type: "nullable",
+    innerType: e
+  });
+}
+const us = /* @__PURE__ */ c("ZodDefault", (e, t) => {
+  Fr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => ri(e, n, r, o), e.unwrap = () => e._zod.def.innerType, e.removeDefault = e.unwrap;
+});
+function ls(e, t) {
+  return new us({
+    type: "default",
+    innerType: e,
+    get defaultValue() {
+      return typeof t == "function" ? t() : Xe(t);
+    }
+  });
+}
+const ps = /* @__PURE__ */ c("ZodPrefault", (e, t) => {
+  Mr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => oi(e, n, r, o), e.unwrap = () => e._zod.def.innerType;
+});
+function hs(e, t) {
+  return new ps({
+    type: "prefault",
+    innerType: e,
+    get defaultValue() {
+      return typeof t == "function" ? t() : Xe(t);
+    }
+  });
+}
+const bt = /* @__PURE__ */ c("ZodNonOptional", (e, t) => {
+  Ur.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => ni(e, n, r, o), e.unwrap = () => e._zod.def.innerType;
+});
+function fs(e, t) {
+  return new bt({
+    type: "nonoptional",
+    innerType: e,
+    ...h(t)
+  });
+}
+const ds = /* @__PURE__ */ c("ZodCatch", (e, t) => {
+  Jr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => ii(e, n, r, o), e.unwrap = () => e._zod.def.innerType, e.removeCatch = e.unwrap;
+});
+function ms(e, t) {
+  return new ds({
+    type: "catch",
+    innerType: e,
+    catchValue: typeof t == "function" ? t : () => t
+  });
+}
+const gs = /* @__PURE__ */ c("ZodPipe", (e, t) => {
+  Vr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => si(e, n, r, o), e.in = t.in, e.out = t.out;
+});
+function Ve(e, t) {
+  return new gs({
+    type: "pipe",
+    in: e,
+    out: t
+    // ...util.normalizeParams(params),
+  });
+}
+const vs = /* @__PURE__ */ c("ZodReadonly", (e, t) => {
+  Gr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => ai(e, n, r, o), e.unwrap = () => e._zod.def.innerType;
+});
+function _s(e) {
+  return new vs({
+    type: "readonly",
+    innerType: e
+  });
+}
+const ys = /* @__PURE__ */ c("ZodCustom", (e, t) => {
+  Wr.init(e, t), k.init(e, t), e._zod.processJSONSchema = (n, r, o) => qo(e, n);
+});
+function ks(e, t = {}) {
+  return Do(ys, e, t);
+}
+function ws(e) {
+  return Lo(e);
+}
+const O = ke([
+  I(),
+  S({
+    pattern: I(),
+    flags: I().optional()
+  })
+]), bs = S({
+  kind: oe("fragment"),
+  condition: O.optional(),
+  operator: ke([I(), N(I())]).optional()
+  // Note: Operator types might need to be refined if we want strict enum validation, 
+  // but string is flexible for now.
+}), zs = S({
+  kind: oe("participant"),
+  name: O.optional(),
+  id: O.optional(),
+  stereotype: O.optional()
+}), $s = S({
+  kind: oe("message"),
+  text: O.optional(),
+  from: O.optional(),
+  to: O.optional()
+}), Ts = S({
+  kind: oe("group"),
+  name: O.optional()
+}), Zs = ns("kind", [
+  bs,
+  zs,
+  $s,
+  Ts
+]), Is = kt(["focus", "remove", "resolve"]), Es = S({
+  action: Is,
+  selector: Zs
+}), Ss = S({
+  name: I(),
+  suffix: I().optional(),
+  // Defaults to .name in logic
+  layers: N(Es)
+}), Os = S({
+  input: N(I()),
+  outputDir: I(),
+  ignore: N(I()).optional(),
+  lenses: N(Ss)
+}), Ps = S({
+  version: Ki(),
+  targets: N(Os)
+});
+function xs(e) {
+  const t = Ps.safeParse(e);
+  if (!t.success) {
+    const n = t.error.issues.map((r) => `[${r.path.join(".")}]: ${r.message}`).join(`
+`);
+    throw new Error(`Invalid Polagram Configuration:
+${n}`);
+  }
+  return t.data;
+}
+export {
+  Dt as FocusFilter,
+  fe as Matcher,
+  Ct as MermaidGeneratorVisitor,
+  ce as ParserFactory,
+  Cs as Polagram,
+  Vt as PolagramBuilder,
+  Ps as PolagramConfigSchema,
+  Lt as RemoveFilter,
+  Ft as ResolveFilter,
+  xt as StructureCleaner,
+  ue as TransformationEngine,
+  Rt as Traverser,
+  jt as UnusedCleaner,
+  Rs as applyLens,
+  Ut as transformerRegistry,
+  xs as validateConfig,
+  As as validateLens
+};