@inploi/plugin-chatbot 3.30.0 → 4.0.0

package/dist/chatbot-body-c80bdc34.js

@@ -0,0 +1,4012 @@
+import { g as Ue, i as tr, k as Le, a as rr, b as le, A as Me, c as Fr, N as Ke, _ as I, d as nr, h as Y, e as re, p as ue, F as mt, u as Z, o as l, f as Ne, j as ft, y as pe, s as M, l as Ze, m as he, n as Lr, q as at, r as ee, t as Nr, v as _e, w as Tr, x as sr, z as Dr, B as ar, C as Rr, D as Se, E as X, G as Or, V as Br, H as ir, I as $e, J as je, K as Pr, L as $r, M as jr, O as zr, P as qr, Q as Ur, R as Lt, S as Kr, T as Gr, U as Hr } from "./index-a2c09edd.js";
+import "@inploi/sdk";
+const Nt = ({
+  condition: e,
+  context: t,
+  submissions: r,
+  ifBlock: n
+}) => {
+  const [s, ...a] = e.compareKey.split(".");
+  if (!s)
+    return !1;
+  const i = lr({
+    context: t,
+    key: s,
+    path: a,
+    submissions: r
+  });
+  if (!i)
+    return !1;
+  switch (i.type) {
+    case "address": {
+      const u = Ue(i.value, a.join("."));
+      switch (e.compare) {
+        case "equals":
+          return u === e.compareValue;
+        case "contains":
+          return u ? u.includes(e.compareValue) : !1;
+        case "notEquals":
+          return u !== e.compareValue;
+        case "notContains":
+          return u ? !u.includes(e.compareValue) : !0;
+      }
+      break;
+    }
+    case "integration": {
+      if (typeof i.value != "object" || Array.isArray(i.value))
+        return !1;
+      const u = Ue(i.value, a.join(".")), c = {
+        ...n,
+        data: {
+          ...n.data,
+          compareKey: "_temp"
+        }
+      };
+      switch (typeof u) {
+        case "boolean":
+          return Fe(c, {
+            submissions: {
+              _temp: {
+                value: u,
+                type: "boolean"
+              }
+            },
+            context: t
+          });
+        case "string":
+          return Fe(c, {
+            submissions: {
+              _temp: {
+                value: u,
+                type: "string"
+              }
+            },
+            context: t
+          });
+        case "number":
+          return Fe(c, {
+            submissions: {
+              _temp: {
+                value: u,
+                type: "number"
+              }
+            },
+            context: t
+          });
+        case "object":
+          return Array.isArray(u) && u.every(tr) ? Fe(c, {
+            submissions: {
+              _temp: {
+                value: u,
+                type: "enum"
+              }
+            },
+            context: t
+          }) : !1;
+      }
+      break;
+    }
+    case "boolean": {
+      const u = e.compareValue === "true";
+      switch (e.compare) {
+        case "equals":
+          return i.value === u;
+        case "notEquals":
+          return i.value !== u;
+      }
+      break;
+    }
+    case "phone":
+    case "string": {
+      const u = i.type === "phone" ? Qe(i.value) : i.value;
+      switch (e.compare) {
+        case "equals":
+          return u === e.compareValue;
+        case "contains":
+          return u ? u.includes(e.compareValue) : !1;
+        case "notEquals":
+          return u !== e.compareValue;
+        case "notContains":
+          return u ? !u.includes(e.compareValue) : !0;
+      }
+      break;
+    }
+    case "number": {
+      try {
+        const u = Number(e.compareValue);
+        switch (e.compare) {
+          case "equals":
+            return i.value === u;
+          case "notEquals":
+            return i.value !== u;
+          case "greaterThan":
+            return i.value > u;
+          case "greaterThanOrEqualTo":
+            return i.value >= u;
+          case "lessThan":
+            return i.value < u;
+          case "lessThanOrEqualTo":
+            return i.value <= u;
+        }
+      } catch {
+        return console.error(`Failed to parse number in if-block ${n.id}`, i.value), !1;
+      }
+      break;
+    }
+    case "enum":
+      switch (e.compare) {
+        case "equals":
+          return i.value.length === 1 && i.value[0] === e.compareValue;
+        case "notEquals":
+          return i.value.length === 1 && i.value[0] !== e.compareValue;
+        case "contains":
+          return i.value.includes(e.compareValue);
+        case "notContains":
+          return !i.value.includes(e.compareValue);
+      }
+      break;
+  }
+}, Fe = (e, {
+  context: t,
+  submissions: r
+}) => {
+  const n = "combinator" in e.data ? e.data.conditions : [e.data];
+  if (("combinator" in e.data ? e.data.combinator : "and") === "or") {
+    for (const a of n)
+      if (Nt({
+        condition: a,
+        context: t,
+        submissions: r,
+        ifBlock: e
+      }))
+        return !0;
+    return !1;
+  } else {
+    for (const a of n)
+      if (!Nt({
+        condition: a,
+        context: t,
+        submissions: r,
+        ifBlock: e
+      }))
+        return !1;
+    return !0;
+  }
+}, Wr = /{{\s*([^}]+?)\s*(?:\|\s*([^}]+?)\s*)?}}/g, ne = (e, {
+  context: t,
+  submissions: r
+}) => e.replace(Wr, (n, s, a = "") => {
+  const [i, ...u] = s.trim().split("."), c = lr({
+    key: i,
+    path: u,
+    submissions: r,
+    context: t
+  });
+  if (!c)
+    return a;
+  switch (c.type) {
+    case "boolean":
+      return c.value === !0 ? "true" : "false";
+    case "file":
+      return c.value.map((h) => `${h.name} (${Le(h.sizeKb)})`).join(", ");
+    case "enum":
+      return c.value.join(", ");
+    case "address":
+      return Object.values(c.value).filter((h) => h && h.trim().length > 0).join(", ");
+    case "number":
+    case "string":
+      return c.value ? c.value.toString() : a;
+    case "phone":
+      return Qe(c.value);
+    case "integration": {
+      if (typeof c.value != "object" || Array.isArray(c.value))
+        break;
+      const h = Ue(c.value, u.join("."));
+      switch (typeof h) {
+        case "boolean":
+          return h === !0 ? "true" : "false";
+        case "string":
+          return h;
+        case "number":
+          return h.toString();
+        case "object":
+          if (Array.isArray(h) && h.every(tr))
+            return h.join(", ");
+      }
+      break;
+    }
+  }
+  return a;
+}), or = ({
+  node: e,
+  nodes: t,
+  stopWhen: r
+}) => {
+  if ((r == null ? void 0 : r(e)) === !0)
+    return e;
+  const n = e.nextId ? t.find((s) => s.id === e.nextId) : void 0;
+  if (n)
+    return or({
+      node: n,
+      nodes: t,
+      stopWhen: r
+    });
+}, Jr = ({
+  childNode: e,
+  nodes: t
+}) => {
+  const n = t.filter((s) => s.type === "if-block").find((s) => {
+    if (!s.branchId)
+      return !1;
+    const a = t.find((u) => u.id === s.branchId);
+    if (!a)
+      return !1;
+    const i = or({
+      node: a,
+      nodes: t,
+      stopWhen: (u) => u.id === e.id
+    });
+    return !(!i || i.id !== e.id);
+  });
+  if (n != null && n.nextId)
+    return t.find((s) => s.id === n.nextId);
+}, Zr = ({
+  flow: e,
+  analytics: t,
+  logger: r,
+  context: n,
+  apiClient: s,
+  getSubmissions: a,
+  chatService: i,
+  onFlowEnd: u,
+  onInterpret: c,
+  t: h
+}) => {
+  let x = new AbortController();
+  const b = {
+    ...t.service,
+    log: (k) => t.service.log({
+      ...k,
+      customProperties: {
+        ...k.customProperties,
+        ...t.customProperties
+      }
+    })
+  }, p = async (k, v) => {
+    const E = a();
+    c == null || c(k, v);
+    try {
+      await Qr({
+        flow: e,
+        analytics: b,
+        logger: r,
+        apiClient: s,
+        context: n,
+        node: k,
+        submissions: E,
+        t: h,
+        chat: {
+          sendMessage: async (S) => i.send({
+            groupId: k.id,
+            message: S,
+            signal: x.signal
+          }),
+          userInput: async (S) => i.input({
+            input: S,
+            signal: x.signal
+          }),
+          addToSubmissions: i.addToSubmissions
+        },
+        next: (S) => {
+          const A = S ? e.nodes.find((g) => g.id === S) : Jr({
+            childNode: k,
+            nodes: e.nodes
+          });
+          return A ? p(A, k) : u == null ? void 0 : u(k);
+        },
+        end: () => u == null ? void 0 : u(k)
+      });
+    } catch (S) {
+      if (S instanceof Me)
+        return;
+      throw S;
+    }
+  };
+  return {
+    interpret: async (k) => {
+      const v = e.nodes.find((E) => E.id === k) ?? rr(e.nodes);
+      return p(v);
+    },
+    undo: (k) => {
+      let v = 1;
+      const E = e.nodes.find((A) => A.id === k[k.length - 1]);
+      for (let A = k.length - 2; A > 0; A--) {
+        const g = k[A], T = e.nodes.find((P) => P.id === g);
+        if (!T || (v++, T.type.startsWith("question-")))
+          break;
+      }
+      x.abort(), x = new AbortController();
+      const S = e.nodes.find((A) => A.id === k[k.length - v]);
+      return le(S, "Undo failed: new start node not found"), p(S, E), {
+        removed: v
+      };
+    },
+    abort: () => {
+      x.abort();
+    }
+  };
+}, Qe = (e) => `+${e.countryCode} ${e.phoneNumber}`;
+async function Qr(e) {
+  const t = e.node;
+  switch (t.type) {
+    case "text":
+      return an({
+        ...e,
+        node: t
+      });
+    case "image":
+      return on({
+        ...e,
+        node: t
+      });
+    case "question-text":
+      return ln({
+        ...e,
+        node: t
+      });
+    case "question-enum":
+      return dn({
+        ...e,
+        node: t
+      });
+    case "question-number":
+      return un({
+        ...e,
+        node: t
+      });
+    case "question-phone":
+      return cn({
+        ...e,
+        node: t
+      });
+    case "question-boolean":
+      return fn({
+        ...e,
+        node: t
+      });
+    case "question-file":
+      return pn({
+        ...e,
+        node: t
+      });
+    case "question-address":
+      return hn({
+        ...e,
+        node: t
+      });
+    case "end-flow":
+      return mn({
+        ...e,
+        node: t
+      });
+    case "if-block":
+      return sn({
+        ...e,
+        node: t
+      });
+    case "jump":
+      return en({
+        ...e,
+        node: t
+      });
+    case "link":
+      return nn({
+        ...e,
+        node: t
+      });
+    case "integration-application-submit":
+      return rn({
+        ...e,
+        node: t
+      });
+    case "add-submission":
+      return tn({
+        ...e,
+        node: t
+      });
+    case "integration-workflow-get":
+      throw Error("Workflow should be unreachable");
+    case "identify":
+      return Yr({
+        ...e,
+        node: t
+      });
+    case "feedback":
+      return Xr({
+        ...e,
+        node: t
+      });
+    default:
+      throw new Error(`Unknown node: ${JSON.stringify(t)}`);
+  }
+}
+const Ie = (e, t) => {
+  var n;
+  const r = (n = e[t]) == null ? void 0 : n.value;
+  if (typeof r != "string" && typeof r != "number")
+    throw new Error(`Submission at “${t}” is not a string or number`);
+  return r;
+};
+async function Xr({
+  next: e,
+  node: t
+}) {
+  e(t.nextId);
+}
+async function Yr({
+  next: e,
+  node: t,
+  analytics: r,
+  submissions: n,
+  logger: s
+}) {
+  if (!n)
+    return e(t.nextId);
+  try {
+    r.log({
+      event: "IDENTIFY",
+      properties: {
+        identifier: Ie(n, t.data.key).toString(),
+        first_name: t.data.firstName ? Ie(n, t.data.firstName).toString() : void 0,
+        last_name: t.data.lastName ? Ie(n, t.data.lastName).toString() : void 0,
+        email: t.data.email ? Ie(n, t.data.email).toString() : void 0,
+        phone_number: t.data.phoneNumber ? Ie(n, t.data.phoneNumber).toString() : void 0,
+        custom_traits: t.data.customTraits ? Object.fromEntries(t.data.customTraits.map(({
+          key: a,
+          value: i
+        }) => {
+          var u;
+          return [a, (u = n[i]) == null ? void 0 : u.value];
+        })) : void 0
+      }
+    });
+  } catch (a) {
+    s.error(a);
+  } finally {
+    e(t.nextId);
+  }
+}
+async function en({
+  next: e,
+  node: t
+}) {
+  e(t.data.targetId);
+}
+async function tn({
+  next: e,
+  node: t,
+  logger: r,
+  submissions: n,
+  context: s
+}) {
+  if (!n) {
+    r.error("Submissions not found");
+    return;
+  }
+  n[t.data.key] = {
+    type: "string",
+    value: ne(t.data.value, {
+      submissions: n,
+      context: s
+    })
+  }, e(t.nextId);
+}
+async function rn({
+  chat: e,
+  next: t,
+  node: r,
+  logger: n,
+  apiClient: s,
+  submissions: a,
+  analytics: i,
+  flow: u,
+  t: c
+}) {
+  const h = async (x) => {
+    x !== !0 && await e.userInput({
+      type: "submit",
+      key: void 0,
+      config: {
+        label: r.data.submitLabel
+      }
+    }), await e.sendMessage({
+      type: "loading"
+    });
+    const {
+      anonymous_id: b,
+      session_id: p
+    } = i.getSessionInfo(), k = await s.fetch("/flow/submit", {
+      method: "POST",
+      body: JSON.stringify({
+        log_submit: !1,
+        integration_id: r.data.integrationId,
+        anonymous_id: b,
+        session_id: p,
+        job: u.job,
+        submissions: Fr(a || {})
+      })
+    }).catch((v) => v);
+    r.data.key && e.addToSubmissions(r.data.key, {
+      type: "integration",
+      value: k
+    }), Ke(k).with({
+      integration_response: I.select(I.union({
+        service: I.optional(I.string),
+        status: I.number,
+        data: I.any
+      }, {
+        service: I.optional(I.string),
+        status: I.number,
+        error: {
+          message: I.string,
+          data: I.any
+        }
+      }))
+    }, (v) => {
+      i.log({
+        event: "FLOW_SUBMIT",
+        properties: {
+          flow_id: u.id,
+          flow_version: u.version,
+          flow_session_id: u.data.flowSessionId,
+          flow_build: u.build,
+          service: v.service ?? "INVALID_SERVICE",
+          response: {
+            status: v.status,
+            payload: "data" in v ? v.data : v.error.data ?? null
+          },
+          job: u.job
+        }
+      });
+    }).otherwise(() => {
+    }), await Ke(k).with(I.union({
+      ats_data: I.select("redirect", {
+        redirect_url: I.string,
+        message: I.optional(I.union(I.string, I.nullish)),
+        button_text: I.optional(I.union(I.string, I.nullish))
+      })
+    }, {
+      integration_response: {
+        data: I.select("redirect", {
+          redirect_url: I.string,
+          message: I.optional(I.union(I.string, I.nullish)),
+          button_text: I.optional(I.union(I.string, I.nullish))
+        })
+      }
+    }), async (v) => {
+      if (v.redirect !== void 0) {
+        await e.sendMessage({
+          type: "text",
+          author: "bot",
+          text: v.redirect.message ?? c("submission_redirect_message")
+        });
+        try {
+          const E = new URL(v.redirect.redirect_url);
+          b && !E.searchParams.has("anonymous_id") && E.searchParams.set("anonymous_id", b), await e.sendMessage({
+            type: "link",
+            href: E.toString(),
+            text: v.redirect.button_text ?? c("complete_submission"),
+            onClick: () => {
+              if (!p) {
+                n.error("session_id not set, cannot log FLOW_REDIRECT event");
+                return;
+              }
+              i.log({
+                event: "FLOW_REDIRECT",
+                properties: {
+                  flow_build: u.build,
+                  flow_id: u.id,
+                  flow_session_id: p,
+                  flow_version: u.version,
+                  href: E.toString(),
+                  job: u.job
+                }
+              });
+            }
+          });
+        } catch (E) {
+          n.error(`Invalid redirect URL: ${v.redirect.redirect_url}`, E), e.sendMessage({
+            type: "system",
+            variant: "error",
+            text: c("redirect_url_error")
+          });
+        }
+        t(r.nextId);
+      }
+    }).with({
+      success: !0
+    }, async () => {
+      r.data.skipConfirmation !== !0 && await e.sendMessage({
+        type: "system",
+        variant: "success",
+        text: c("submission_completed")
+      }), t(r.nextId);
+    }).with(I.union({
+      success: !1,
+      ats_data: I.select("error", {
+        message: I.string
+      })
+    }, {
+      integration_response: {
+        error: I.select("error", {
+          message: I.string
+        })
+      }
+    }), async (v) => {
+      var E;
+      n.error(v.error), await e.sendMessage({
+        type: "system",
+        variant: "error",
+        text: ((E = v.error) == null ? void 0 : E.message) || c("submission_failed")
+      }), await h(!1);
+    }).otherwise(async (v) => {
+      n.error(v), await e.sendMessage({
+        type: "system",
+        variant: "error",
+        text: c("submission_failed")
+      }), await h(!1);
+    });
+  };
+  await h(r.data.skipConfirmation);
+}
+async function nn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: s
+}) {
+  await e.sendMessage({
+    type: "link",
+    href: ne(r.data.href, {
+      submissions: n,
+      context: s
+    }),
+    text: ne(r.data.cta, {
+      submissions: n,
+      context: s
+    })
+  }), t(r.nextId);
+}
+async function sn({
+  submissions: e,
+  next: t,
+  node: r,
+  context: n
+}) {
+  t(Fe(r, {
+    submissions: e,
+    context: n
+  }) ? r.branchId : r.nextId);
+}
+async function an({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: s
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ne(r.data.text, {
+      submissions: n,
+      context: s
+    })
+  }), t(r.nextId);
+}
+async function on({
+  chat: e,
+  next: t,
+  node: r
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "image",
+    url: r.data.url,
+    height: r.data.height,
+    width: r.data.width
+  }), t(r.nextId);
+}
+async function ln({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: s,
+  t: a
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ne(r.data.question, {
+      submissions: n,
+      context: s
+    })
+  });
+  const i = r.data.format === "phone" ? await e.userInput({
+    key: r.data.key,
+    type: "phone",
+    config: {
+      optional: r.data.optional,
+      placeholder: r.data.placeholder,
+      maxChars: r.data.maxChars,
+      minChars: r.data.minChars,
+      submissionFormat: "text",
+      defaultValue: {}
+    }
+  }) : await e.userInput({
+    key: r.data.key,
+    type: "text",
+    config: {
+      optional: r.data.optional,
+      placeholder: r.data.placeholder,
+      format: r.data.format,
+      maxChars: r.data.maxChars,
+      minChars: r.data.minChars
+    }
+  });
+  i === null ? await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: a("skipped")
+  }) : await e.sendMessage({
+    author: "user",
+    type: "text",
+    text: i.type === "phone" ? Qe(i.value) : i.value
+  }), t(r.nextId);
+}
+async function un({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: s,
+  t: a
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ne(r.data.question, {
+      submissions: n,
+      context: s
+    })
+  });
+  const i = await e.userInput({
+    key: r.data.key,
+    type: "number",
+    config: {
+      max: r.data.max,
+      min: r.data.min,
+      optional: r.data.optional,
+      placeholder: r.data.placeholder,
+      decimalCases: r.data.decimalCases
+    }
+  });
+  i === null ? await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: a("skipped")
+  }) : await e.sendMessage({
+    author: "user",
+    type: "text",
+    text: i.value.toString()
+  }), t(r.nextId);
+}
+async function cn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: s
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ne(r.data.question, {
+      submissions: n,
+      context: s
+    })
+  });
+  const a = await e.userInput({
+    key: r.data.key,
+    type: "phone",
+    config: {
+      minChars: r.data.minChars,
+      maxChars: r.data.maxChars,
+      defaultValue: {
+        countryCode: r.data.defaultCountryCode
+      },
+      placeholder: r.data.placeholder,
+      submissionFormat: "phone",
+      optional: r.data.optional
+    }
+  });
+  a === null ? await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: "Skipped"
+  }) : await e.sendMessage({
+    author: "user",
+    type: "text",
+    text: a.type === "phone" ? Qe(a.value) : a.value
+  }), t(r.nextId);
+}
+async function dn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: s,
+  t: a
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ne(r.data.question, {
+      submissions: n,
+      context: s
+    })
+  });
+  const i = await e.userInput({
+    key: r.data.key,
+    type: "multiple-choice",
+    config: r.data
+  });
+  i.value.length === 0 ? await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: a("skipped")
+  }) : await e.sendMessage({
+    author: "user",
+    type: "text",
+    text: r.data.options.filter((u) => i.value.includes(u.value)).map((u) => u.label).join(", ")
+  }), t(r.nextId);
+}
+async function fn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: s,
+  t: a
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ne(r.data.question, {
+      submissions: n,
+      context: s
+    })
+  });
+  const i = await e.userInput({
+    key: r.data.key,
+    type: "boolean",
+    config: {
+      optional: r.data.optional,
+      labels: {
+        true: r.data.trueLabel,
+        false: r.data.falseLabel
+      }
+    }
+  });
+  i === null ? await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: a("skipped")
+  }) : await e.sendMessage({
+    author: "user",
+    type: "text",
+    text: i.value === !0 ? r.data.trueLabel : r.data.falseLabel
+  }), t(r.nextId);
+}
+async function hn({
+  chat: e,
+  next: t,
+  node: r,
+  t: n
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: r.data.question
+  });
+  const s = await e.userInput({
+    type: "address",
+    key: r.data.key,
+    config: {
+      optional: r.data.optional,
+      keys: r.data.keys,
+      placeholder: r.data.placeholder
+    }
+  });
+  if (s === null)
+    await e.sendMessage({
+      type: "system",
+      variant: "info",
+      text: n("skipped")
+    });
+  else {
+    const a = Object.values(s.value).filter((i) => i && i.trim().length > 0).join(", ");
+    await e.sendMessage({
+      author: "user",
+      type: "text",
+      text: a
+    });
+  }
+  return t(r.nextId);
+}
+async function pn({
+  node: e,
+  chat: t,
+  next: r,
+  submissions: n,
+  context: s,
+  t: a
+}) {
+  await t.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ne(e.data.question, {
+      submissions: n,
+      context: s
+    })
+  });
+  const i = await t.userInput({
+    key: e.data.key,
+    type: "file",
+    config: {
+      optional: e.data.optional,
+      extensions: e.data.extensions,
+      // default value for fileSizeLimitKib is 10MB
+      fileSizeLimitKib: e.data.maxSizeKb ?? 10 * 1024,
+      allowMultiple: e.data.multiple === !0
+    }
+  });
+  if (i === null)
+    await t.sendMessage({
+      type: "system",
+      variant: "info",
+      text: a("skipped")
+    });
+  else
+    for (const u of i.value)
+      await t.sendMessage({
+        author: "user",
+        type: "file",
+        fileName: u.name,
+        fileSizeKb: u.sizeKb
+      });
+  r(e.nextId);
+}
+async function mn({
+  chat: e,
+  end: t,
+  node: r
+}) {
+  await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: r.data.systemMessage
+  }), t();
+}
+const lr = ({
+  key: e,
+  path: t,
+  submissions: r,
+  context: n
+}) => {
+  if (e === "$context") {
+    if (!t)
+      return;
+    const s = Ue(n, t.join("."));
+    switch (typeof s) {
+      case "string":
+        return {
+          type: "string",
+          value: s
+        };
+      case "number":
+        return {
+          type: "number",
+          value: s
+        };
+      case "boolean":
+        return {
+          type: "boolean",
+          value: s
+        };
+      default:
+        console.warn(`Unexpected type for $context.${t.join(".")}`, s);
+        return;
+    }
+  }
+  return r == null ? void 0 : r[e];
+};
+function ht(e, t, r) {
+  var n, s, a, i, u;
+  t == null && (t = 100);
+  function c() {
+    var x = Date.now() - i;
+    x < t && x >= 0 ? n = setTimeout(c, t - x) : (n = null, r || (u = e.apply(a, s), a = s = null));
+  }
+  var h = function() {
+    a = this, s = arguments, i = Date.now();
+    var x = r && !n;
+    return n || (n = setTimeout(c, t)), x && (u = e.apply(a, s), a = s = null), u;
+  };
+  return h.clear = function() {
+    n && (clearTimeout(n), n = null);
+  }, h.flush = function() {
+    n && (u = e.apply(a, s), a = s = null, clearTimeout(n), n = null);
+  }, h;
+}
+ht.debounce = ht;
+var gn = ht;
+const Tt = /* @__PURE__ */ nr(gn);
+function yn(e) {
+  let {
+    debounce: t,
+    scroll: r,
+    polyfill: n,
+    offsetSize: s
+  } = e === void 0 ? {
+    debounce: 0,
+    scroll: !1,
+    offsetSize: !1
+  } : e;
+  const a = n || (typeof window > "u" ? class {
+  } : window.ResizeObserver);
+  if (!a)
+    throw new Error("This browser does not support ResizeObserver out of the box. See: https://github.com/react-spring/react-use-measure/#resize-observer-polyfills");
+  const [i, u] = Y({
+    left: 0,
+    top: 0,
+    width: 0,
+    height: 0,
+    bottom: 0,
+    right: 0,
+    x: 0,
+    y: 0
+  }), c = re({
+    element: null,
+    scrollContainers: null,
+    resizeObserver: null,
+    lastBounds: i
+  }), h = t ? typeof t == "number" ? t : t.scroll : null, x = t ? typeof t == "number" ? t : t.resize : null, b = re(!1);
+  ue(() => (b.current = !0, () => void (b.current = !1)));
+  const [p, k, v] = mt(() => {
+    const g = () => {
+      if (!c.current.element)
+        return;
+      const {
+        left: T,
+        top: P,
+        width: D,
+        height: me,
+        bottom: ce,
+        right: Ae,
+        x: G,
+        y: se
+      } = c.current.element.getBoundingClientRect(), q = {
+        left: T,
+        top: P,
+        width: D,
+        height: me,
+        bottom: ce,
+        right: Ae,
+        x: G,
+        y: se
+      };
+      c.current.element instanceof HTMLElement && s && (q.height = c.current.element.offsetHeight, q.width = c.current.element.offsetWidth), Object.freeze(q), b.current && !wn(c.current.lastBounds, q) && u(c.current.lastBounds = q);
+    };
+    return [g, x ? Tt(g, x) : g, h ? Tt(g, h) : g];
+  }, [u, s, h, x]);
+  function E() {
+    c.current.scrollContainers && (c.current.scrollContainers.forEach((g) => g.removeEventListener("scroll", v, !0)), c.current.scrollContainers = null), c.current.resizeObserver && (c.current.resizeObserver.disconnect(), c.current.resizeObserver = null);
+  }
+  function S() {
+    c.current.element && (c.current.resizeObserver = new a(v), c.current.resizeObserver.observe(c.current.element), r && c.current.scrollContainers && c.current.scrollContainers.forEach((g) => g.addEventListener("scroll", v, {
+      capture: !0,
+      passive: !0
+    })));
+  }
+  const A = (g) => {
+    !g || g === c.current.element || (E(), c.current.element = g, c.current.scrollContainers = ur(g), S());
+  };
+  return vn(v, !!r), bn(k), ue(() => {
+    E(), S();
+  }, [r, v, k]), ue(() => E, []), [A, i, p];
+}
+function bn(e) {
+  ue(() => {
+    const t = e;
+    return window.addEventListener("resize", t), () => void window.removeEventListener("resize", t);
+  }, [e]);
+}
+function vn(e, t) {
+  ue(() => {
+    if (t) {
+      const r = e;
+      return window.addEventListener("scroll", r, {
+        capture: !0,
+        passive: !0
+      }), () => void window.removeEventListener("scroll", r, !0);
+    }
+  }, [e, t]);
+}
+function ur(e) {
+  const t = [];
+  if (!e || e === document.body)
+    return t;
+  const {
+    overflow: r,
+    overflowX: n,
+    overflowY: s
+  } = window.getComputedStyle(e);
+  return [r, n, s].some((a) => a === "auto" || a === "scroll") && t.push(e), [...t, ...ur(e.parentElement)];
+}
+const xn = ["x", "y", "top", "bottom", "left", "right", "width", "height"], wn = (e, t) => xn.every((r) => e[r] === t[r]), be = ({
+  class: e,
+  ...t
+}) => {
+  const {
+    t: r
+  } = Z();
+  return l("button", {
+    class: Ne("bg-accent-9 active:bg-accent-10 pointer-coarse:touch-hitbox fr flex-shrink-0 rounded-full p-2 text-white transition-all disabled:cursor-not-allowed disabled:opacity-50", e),
+    type: "submit",
+    ...t,
+    children: l("svg", {
+      class: "block",
+      width: "16",
+      height: "16",
+      viewBox: "0 0 16 16",
+      fill: "transparent",
+      stroke: "currentColor",
+      "stroke-linecap": "round",
+      "stroke-width": "2",
+      children: [l("title", {
+        children: r("send")
+      }), l("path", {
+        d: "M3.5 7.5L8 3L12.5 7.5"
+      }), l("path", {
+        d: "M8 4V13"
+      })]
+    })
+  });
+}, kn = 25, pt = ft({
+  instant: () => {
+  },
+  smooth: () => {
+  }
+}), z = {
+  onSubmitSuccessFn$: ft(() => {
+  }),
+  isBotTyping$: ft(!1),
+  scrollToEnd: {
+    instant: () => pt.value.instant(),
+    smooth: () => pt.value.smooth()
+  }
+}, _n = () => {
+  const e = re(null);
+  pe(() => {
+    pt.value = {
+      instant: () => {
+        var r;
+        return (r = e.current) == null ? void 0 : r.scrollTo({
+          top: e.current.scrollHeight,
+          behavior: "instant"
+        });
+      },
+      smooth: () => {
+        e.current && e.current.scrollHeight - e.current.scrollTop <= e.current.clientHeight * 2 && e.current.scrollTo({
+          top: e.current.scrollHeight,
+          behavior: "smooth"
+        });
+      }
+    };
+  }, [e]);
+  const t = mt(() => ({
+    addToSubmissions: (n, s) => M.setSubmission(n, s),
+    send: async ({
+      message: n,
+      signal: s,
+      groupId: a
+    }) => {
+      if (await Ke(n).with({
+        author: "bot",
+        type: "text"
+      }, async (i) => {
+        if (s != null && s.aborted)
+          throw new Me();
+        z.isBotTyping$.value = !0;
+        const u = Math.min(Math.max(20, i.text.length), 100) * kn;
+        await new Promise((c) => setTimeout(c, u, {
+          signal: s
+        })), z.isBotTyping$.value = !1;
+      }).otherwise(async () => {
+      }), s != null && s.aborted)
+        throw new Me();
+      M.addMessage(n, a);
+    },
+    input: ({
+      input: n,
+      signal: s
+    }) => {
+      if (s != null && s.aborted)
+        throw new Me();
+      return M.setInput(n), new Promise((a) => {
+        const i = (u) => {
+          if (s != null && s.aborted)
+            throw new Me();
+          M.setInput(void 0), n.key && M.setSubmission(n.key, u), a(u);
+        };
+        z.onSubmitSuccessFn$.value = i;
+      });
+    }
+  }), []);
+  return {
+    chatRef: e,
+    chatService: t
+  };
+}, Ce = ({
+  error: e
+}) => !e || !e.message ? null : l("div", {
+  role: "alert",
+  class: "text-error-11 flex max-w-full items-center gap-1 overflow-hidden rounded-full px-2 py-2",
+  children: [l("svg", {
+    class: "text-error-9 h-4 w-4",
+    viewBox: "0 0 16 16",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: [l("circle", {
+      cx: "8",
+      cy: "8",
+      r: "6.3",
+      stroke: "currentColor",
+      "stroke-width": "1.4"
+    }), l("rect", {
+      x: "7",
+      y: "4",
+      width: "2",
+      height: "5",
+      fill: "currentColor"
+    }), l("rect", {
+      x: "7",
+      y: "10",
+      width: "2",
+      height: "2",
+      fill: "currentColor"
+    })]
+  }), l("p", {
+    class: "truncate pr-1 text-sm",
+    children: e.message
+  })]
+}), ve = ({
+  class: e,
+  ...t
+}) => {
+  const {
+    t: r
+  } = Z();
+  return l("button", {
+    type: "button",
+    class: Ne("fr text-neutral-9 flex flex-shrink-0 items-center justify-center gap-1 rounded-full py-[6px] pl-2 pr-3 text-sm underline-offset-2 transition-all", e),
+    ...t,
+    children: [l("svg", {
+      "aria-hidden": !0,
+      class: "block",
+      width: "16",
+      height: "16",
+      viewBox: "0 0 16 16",
+      fill: "transparent",
+      stroke: "currentColor",
+      "stroke-linecap": "round",
+      "stroke-width": "1.5",
+      children: [l("title", {
+        children: r("skip")
+      }), l("path", {
+        d: "M3.25 11.25A5 5 0 0 1 12 7"
+      }), l("path", {
+        d: "M13.25 4.5V8.25H9.5"
+      })]
+    }), r("skip")]
+  });
+}, gt = {
+  Afghanistan: "93",
+  Albania: "355",
+  Algeria: "213",
+  "American Samoa": "1 684",
+  Andorra: "376",
+  Angola: "244",
+  Anguilla: "1 264",
+  Antarctica: "672",
+  "Antigua and Barbuda": "1 268",
+  Argentina: "54",
+  Armenia: "374",
+  Aruba: "297",
+  Australia: "61",
+  Austria: "43",
+  Azerbaijan: "994",
+  Bahrain: "973",
+  Bangladesh: "880",
+  Barbados: "1 246",
+  Belarus: "375",
+  Belgium: "32",
+  Belize: "501",
+  Benin: "229",
+  Bermuda: "1 441",
+  Bhutan: "975",
+  Bolivia: "591",
+  "Bosnia and Herzegovina": "387",
+  Botswana: "267",
+  "Bouvet Island": "47",
+  Brazil: "55",
+  "British Indian Ocean Territory": "246",
+  "British Virgin Islands": "1 284",
+  Brunei: "673",
+  Bulgaria: "359",
+  "Burkina Faso": "226",
+  Burundi: "257",
+  "Cabo Verde": "238",
+  Cambodia: "855",
+  Cameroon: "237",
+  Canada: "1",
+  "Caribbean Netherlands": "599",
+  "Cayman Islands": "1 345",
+  "Central African Republic": "236",
+  Chad: "235",
+  Chile: "56",
+  China: "86",
+  "Christmas Island": "61",
+  "Cocos (Keeling) Islands": "61",
+  Colombia: "57",
+  Comoros: "269",
+  "Cook Islands": "682",
+  "Costa Rica": "506",
+  Croatia: "385",
+  Cuba: "53",
+  Curaçao: "599",
+  Cyprus: "357",
+  Czechia: "420",
+  "Côte d'Ivoire": "225",
+  "Democratic Republic of the Congo": "243",
+  Denmark: "45",
+  Djibouti: "253",
+  "Dominican Republic": "1 809",
+  Ecuador: "593",
+  Egypt: "20",
+  "El Salvador": "503",
+  "Equatorial Guinea": "240",
+  Eritrea: "291",
+  Estonia: "372",
+  Eswatini: "268",
+  Ethiopia: "251",
+  "Falkland Islands (Islas Malvinas)": "500",
+  "Faroe Islands": "298",
+  Fiji: "679",
+  Finland: "358",
+  France: "33",
+  "French Guiana": "594",
+  "French Polynesia": "689",
+  "French Southern and Antarctic Lands": "262",
+  Gabon: "241",
+  Georgia: "995",
+  Germany: "49",
+  Ghana: "233",
+  Gibraltar: "350",
+  Greece: "30",
+  Greenland: "299",
+  Grenada: "1 473",
+  Guadeloupe: "590",
+  Guam: "1 671",
+  Guatemala: "502",
+  Guernsey: "44",
+  Guinea: "224",
+  "Guinea-Bissau": "245",
+  Guyana: "592",
+  Haiti: "509",
+  Honduras: "504",
+  "Hong Kong": "852",
+  Hungary: "36",
+  Iceland: "354",
+  India: "91",
+  Indonesia: "62",
+  Iran: "98",
+  Iraq: "964",
+  Ireland: "353",
+  "Isle of Man": "44",
+  Israel: "972",
+  Italy: "39",
+  Jamaica: "1 876",
+  Japan: "81",
+  Jersey: "44",
+  Jordan: "962",
+  Kazakhstan: "7",
+  Kenya: "254",
+  Kiribati: "686",
+  Kosovo: "383",
+  Kuwait: "965",
+  Kyrgyzstan: "996",
+  Laos: "856",
+  Latvia: "371",
+  Lebanon: "961",
+  Lesotho: "266",
+  Liberia: "231",
+  Libya: "218",
+  Liechtenstein: "423",
+  Lithuania: "370",
+  Luxembourg: "352",
+  Macao: "853",
+  Madagascar: "261",
+  Malawi: "265",
+  Malaysia: "60",
+  Maldives: "960",
+  Mali: "223",
+  Malta: "356",
+  "Marshall Islands": "692",
+  Martinique: "596",
+  Mauritania: "222",
+  Mauritius: "230",
+  Mayotte: "262",
+  Mexico: "52",
+  Micronesia: "691",
+  Moldova: "373",
+  Monaco: "377",
+  Mongolia: "976",
+  Montenegro: "382",
+  Montserrat: "1 664",
+  Morocco: "212",
+  Mozambique: "258",
+  "Myanmar (Burma)": "95",
+  Namibia: "264",
+  Nauru: "674",
+  Nepal: "977",
+  Netherlands: "31",
+  "New Caledonia": "687",
+  "New Zealand": "64",
+  Nicaragua: "505",
+  Niger: "227",
+  Nigeria: "234",
+  Niue: "683",
+  "Norfolk Island": "672",
+  "North Korea": "850",
+  "North Macedonia": "389",
+  "Northern Mariana Islands": "1 670",
+  Norway: "47",
+  Oman: "968",
+  Pakistan: "92",
+  Palau: "680",
+  Palestine: "970",
+  Panama: "507",
+  "Papua New Guinea": "675",
+  Paraguay: "595",
+  Peru: "51",
+  Philippines: "63",
+  "Pitcairn Islands": "64",
+  Poland: "48",
+  Portugal: "351",
+  "Puerto Rico": "1 787",
+  Qatar: "974",
+  Romania: "40",
+  Russia: "7",
+  Rwanda: "250",
+  Réunion: "262",
+  "Saint Barthélemy": "590",
+  "Saint Helena, Ascension and Tristan da Cunha": "290",
+  "Saint Kitts and Nevis": "1 869",
+  "Saint Lucia": "1 758",
+  "Saint Martin": "590",
+  "Saint Pierre and Miquelon": "508",
+  "Saint Vincent and the Grenadines": "1 784",
+  Samoa: "685",
+  "San Marino": "378",
+  "Saudi Arabia": "966",
+  Senegal: "221",
+  Serbia: "381",
+  Seychelles: "248",
+  "Sierra Leone": "232",
+  Singapore: "65",
+  "Sint Maarten": "1 721",
+  Slovakia: "421",
+  Slovenia: "386",
+  "Solomon Islands": "677",
+  Somalia: "252",
+  "South Africa": "27",
+  "South Georgia and the South Sandwich Islands": "500",
+  "South Korea": "82",
+  "South Sudan": "211",
+  Spain: "34",
+  "Sri Lanka": "94",
+  Sudan: "249",
+  Suriname: "597",
+  "Svalbard and Jan Mayen": "47",
+  Sweden: "46",
+  Switzerland: "41",
+  Syria: "963",
+  "São Tomé and Príncipe": "239",
+  Taiwan: "886",
+  Tajikistan: "992",
+  Tanzania: "255",
+  Thailand: "66",
+  "The Bahamas": "1 242",
+  "The Gambia": "220",
+  "Timor-Leste": "670",
+  Togo: "228",
+  Tokelau: "690",
+  Tonga: "676",
+  "Trinidad and Tobago": "1 868",
+  Tunisia: "216",
+  Turkmenistan: "993",
+  "Turks and Caicos Islands": "1 649",
+  Tuvalu: "688",
+  Türkiye: "90",
+  "U.S. Virgin Islands": "1 340",
+  Uganda: "256",
+  Ukraine: "380",
+  "United Arab Emirates": "971",
+  "United Kingdom": "44",
+  "United States": "1",
+  "United States Minor Outlying Islands": "1",
+  Uruguay: "598",
+  Uzbekistan: "998",
+  Vanuatu: "678",
+  "Vatican City": "379",
+  Venezuela: "58",
+  Vietnam: "84",
+  "Wallis and Futuna": "681",
+  "Western Sahara": "212",
+  Yemen: "967",
+  Zambia: "260",
+  Zimbabwe: "263",
+  "Åland Islands": "358"
+}, Te = Ze("outline-divider ease-expo-out placeholder:text-neutral-10 text-neutral-12 focus-visible:outline-accent-7 caret-accent-9 bg-lowest py-1 text-base outline outline-2 transition-all", {
+  variants: {
+    optional: {
+      true: "pr-16 pl-3",
+      false: "pl-3 pr-3"
+    }
+  },
+  defaultVariants: {
+    optional: !1
+  }
+}), Sn = "https://api.mapbox.com/search/searchbox/v1/suggest", Cn = "ZzRDWFU0dTZ3SF9aWk9RNGl6QzZaWS5RZmlFak13a0hPbGxXZXlNSGN5RUhObUJ6TXpSV08yUW5OdE5tSTZJU1lpd2lJb1JYYXRObmJ2Tm5iaGhHZWx4V1lpb2pJMUp5ZS5rcA==", An = (e) => atob(e).split("").reverse().join(""), ae = he({
+  name: ee()
+}), En = he({
+  suggestions: Lr(he({
+    full_address: at(ee()),
+    place_formatted: at(ee()),
+    name: at(ee()),
+    mapbox_id: ee(),
+    context: Nr(he({
+      address: ae,
+      street: ae,
+      neighborhood: ae,
+      locality: ae,
+      district: ae,
+      place: ae,
+      region: ae,
+      postcode: ae,
+      country: ae
+    }))
+  }))
+}), In = ({
+  logger: e,
+  t
+}) => mt(() => {
+  var n;
+  const r = (n = M.current$.peek().flow) == null ? void 0 : n.data.flowSessionId;
+  return r ? {
+    enabled: !0,
+    getPredictions: async (s) => {
+      const a = new URL(Sn);
+      a.searchParams.set("q", s), a.searchParams.set("session_token", r), a.searchParams.set("access_token", An(Cn));
+      const i = await fetch(a);
+      if (!i.ok)
+        return e.error("Failed to get address details", i), {
+          ok: !1,
+          error: t("address_error")
+        };
+      const u = Tr(En, await i.json());
+      if (u.success === !1)
+        return e.error("Failed to parse address details", u.issues), {
+          ok: !1,
+          error: t("address_error")
+        };
+      const {
+        suggestions: c
+      } = u.output;
+      return {
+        ok: !0,
+        data: c.map((h) => {
+          var x, b, p, k, v, E, S, A, g;
+          return {
+            label: h.full_address ?? h.place_formatted ?? h.name ?? h.mapbox_id,
+            id: h.mapbox_id,
+            address: {
+              line1: ((x = h.context.address) == null ? void 0 : x.name) ?? ((b = h.context.street) == null ? void 0 : b.name),
+              line2: void 0,
+              line3: ((p = h.context.neighborhood) == null ? void 0 : p.name) ?? ((k = h.context.locality) == null ? void 0 : k.name),
+              city: ((v = h.context.place) == null ? void 0 : v.name) ?? ((E = h.context.district) == null ? void 0 : E.name),
+              state: (S = h.context.region) == null ? void 0 : S.name,
+              postcode: (A = h.context.postcode) == null ? void 0 : A.name,
+              country: (g = h.context.country) == null ? void 0 : g.name
+            }
+          };
+        })
+      };
+    }
+  } : {
+    enabled: !1
+  };
+}, [e, t]), Dt = (e) => {
+  const {
+    t
+  } = Z();
+  return l("button", {
+    type: "button",
+    class: "text-neutral-10 hover:bg-neutral-4 hover:text-neutral-12 hover:border-neutral-5 flex items-center gap-1 rounded-[18px] border border-solid border-transparent px-3 py-1 pl-1.5 text-sm transition-colors",
+    ...e,
+    children: [l("svg", {
+      width: "16",
+      height: "16",
+      viewBox: "0 0 16 16",
+      stroke: "currentColor",
+      "stroke-width": "1.5",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: l("path", {
+        d: "M10 3L5 8L10 13"
+      })
+    }), l("span", {
+      children: t("back")
+    })]
+  });
+}, Vn = ({
+  input: e,
+  onSubmitSuccess: t,
+  logger: r
+}) => {
+  const {
+    t: n
+  } = Z(), [s, a] = Y(), [i, u] = Y([]), {
+    enabled: c,
+    getPredictions: h
+  } = In({
+    logger: r,
+    t: n
+  }), [x, b] = Y(c ? "query" : "manual"), [p, k] = Y(""), [v, E] = Y(), S = (A) => {
+    le(c, "Query state should not be enabled"), A = A.trim(), A !== (p == null ? void 0 : p.trim()) && (k(A), A === "" && u([]), E(void 0), h(A).then((g) => {
+      if (g.ok === !1) {
+        u([]), E(g.error);
+        return;
+      }
+      u(g.data);
+    }));
+  };
+  switch (x) {
+    case "query":
+      return le(c, "Query state should not be enabled"), l(Mn, {
+        input: e,
+        onSkip: () => t(null),
+        onAddressSelect: (A) => {
+          if (A === "") {
+            a(void 0), b("manual");
+            return;
+          }
+          const g = i.find((T) => T.id === A);
+          g && (a(g.address), b("details"));
+        },
+        onAddressSearch: (A) => {
+          S(A);
+        },
+        suggestions: i,
+        query: p,
+        error: v
+      });
+    case "details":
+      return le(s !== void 0), l(Ot, {
+        input: e,
+        logger: r,
+        onSubmitSuccess: t,
+        addressFields: s,
+        actions: l(Dt, {
+          onClick: () => {
+            b("query");
+          }
+        })
+      });
+    case "manual":
+      return l(Ot, {
+        logger: r,
+        input: e,
+        onSubmitSuccess: t,
+        addressFields: {},
+        actions: c ? l(Dt, {
+          onClick: () => {
+            b("query");
+          }
+        }) : void 0
+      });
+  }
+}, Mn = ({
+  input: e,
+  onSkip: t,
+  suggestions: r,
+  onAddressSelect: n,
+  query: s,
+  onAddressSearch: a,
+  error: i
+}) => {
+  const {
+    t: u
+  } = Z(), c = re(null);
+  return pe(() => {
+    c.current && (c.current.focus(), c.current.select());
+  }, []), l(_e, {
+    children: [l("form", {
+      noValidate: !0,
+      onSubmit: (h) => {
+        h.preventDefault();
+        const b = new FormData(h.currentTarget).get("address");
+        typeof b == "string" && a(b);
+      },
+      class: "flex gap-1 p-2.5",
+      children: [l("div", {
+        class: "group relative flex-1",
+        children: [l("input", {
+          ref: c,
+          name: "address",
+          id: "chat-address",
+          autocomplete: "address-line1 country-name postal-code",
+          autoFocus: !0,
+          placeholder: e.config.placeholder || u("address_search"),
+          defaultValue: s,
+          class: Te({
+            optional: !!e.config.optional,
+            className: "w-full rounded-full"
+          })
+        }), l("button", {
+          type: "submit",
+          class: "touch-hitbox text-neutral-12 hover:bg-neutral-3 fr absolute bottom-0 right-0 top-0 flex cursor-pointer items-center gap-1 rounded-full px-3 transition-all",
+          children: l("svg", {
+            width: "16",
+            height: "16",
+            viewBox: "0 0 16 16",
+            fill: "none",
+            xmlns: "http://www.w3.org/2000/svg",
+            children: [l("g", {
+              id: "inploi",
+              stroke: "currentColor",
+              "stroke-linecap": "round",
+              "stroke-linejoin": "round",
+              strokeWidth: "1.5",
+              children: [l("circle", {
+                cx: "7",
+                cy: "7",
+                r: "4"
+              }), l("path", {
+                d: "M10 10L13 13"
+              })]
+            }), l("span", {
+              class: "sr-only",
+              children: u("search")
+            })]
+          })
+        })]
+      }), e.config.optional && l(ve, {
+        class: "",
+        onClick: t
+      })]
+    }), i ? l(Ce, {
+      error: {
+        message: i
+      }
+    }) : null, l("ul", {
+      children: [r.map((h) => l("li", {
+        children: l("button", {
+          class: "text-neutral-11 fr hover:bg-neutral-3 focus-visible:bg-neutral-3 hover:text-neutral-12 border-b-neutral-3 flex w-full items-center border border-b border-solid border-transparent px-4 py-3 text-sm transition-colors duration-100",
+          onClick: () => {
+            n(h.id);
+          },
+          children: [l("span", {
+            class: "flex-grow",
+            children: h.label
+          }), l("svg", {
+            class: "flex-none",
+            width: "16",
+            height: "16",
+            viewBox: "0 0 16 16",
+            stroke: "currentColor",
+            "stroke-width": "1.5",
+            fill: "none",
+            xmlns: "http://www.w3.org/2000/svg",
+            children: l("path", {
+              d: "M6 3L11 8L6 13"
+            })
+          })]
+        })
+      }, h.id)), l("li", {
+        children: l("button", {
+          class: "text-neutral-11 fr hover:bg-neutral-3 focus-visible:bg-neutral-3 hover:text-neutral-12 border-b-neutral-3 flex w-full items-center border border-b border-solid border-transparent px-4 py-3 text-sm transition-colors duration-100",
+          onClick: () => {
+            n("");
+          },
+          children: l("span", {
+            class: "flex-grow",
+            children: u("address_manual")
+          })
+        })
+      }, "")]
+    })]
+  });
+}, Fn = {
+  line1: "Line 1",
+  line2: "Line 2",
+  line3: "Line 3",
+  city: "City",
+  state: "State",
+  postcode: "Postcode",
+  country: "Country"
+}, Rt = ["line1", "line2", "line3", "city", "state", "postcode", "country"], Ot = ({
+  addressFields: e,
+  onSubmitSuccess: t,
+  actions: r,
+  input: n
+}) => {
+  const s = re(null);
+  pe(() => {
+    if (s.current) {
+      const i = s.current.querySelector("input");
+      i && (i.focus(), i.select());
+    }
+  }, []);
+  const a = Object.keys(gt);
+  return l("form", {
+    class: "bg-neutral-1/90 flex flex-col justify-end gap-2 p-2",
+    onSubmit: (i) => {
+      const u = new FormData(i.currentTarget), c = Object.fromEntries(u.entries());
+      t({
+        type: "address",
+        value: c
+      });
+    },
+    children: [l("div", {
+      class: "bg-neutral-3 border-neutral-5 grid items-center gap-1.5 rounded-2xl border pb-2 pl-4 pr-3 pt-3 [grid-template-columns:min-content_1fr]",
+      ref: s,
+      children: Rt.map((i, u) => {
+        const c = `isdk_${i}`, h = n.config.keys[i];
+        return h ? l(_e, {
+          children: [l("label", {
+            for: c,
+            class: "text-neutral-9 [&:has(+*>input:focus)]:text-neutral-11 w-24 pb-2 text-xs uppercase leading-3 tracking-widest transition-colors",
+            children: Fn[i]
+          }), l("div", {
+            class: "flex flex-col items-stretch gap-1.5",
+            children: [i === "country" ? l("div", {
+              class: "relative",
+              children: [l("select", {
+                class: "text-neutral-12 hover:bg-neutral-4 placeholder:text-neutral-8 focus:bg-neutral-5 w-full  flex-1 appearance-none rounded-lg border-solid bg-transparent bg-none px-3 py-1.5 text-base transition-colors focus:outline-none",
+                name: h,
+                id: c,
+                defaultValue: e[i],
+                required: !0,
+                children: [e.country && !a.includes(e.country) ? l("option", {
+                  value: e[i],
+                  children: e[i]
+                }) : l("option", {
+                  value: "",
+                  children: "Select a country"
+                }), a.map((x) => l("option", {
+                  value: x,
+                  children: x
+                }, x))]
+              }), l("svg", {
+                class: "text-neutral-12  absolute bottom-2.5 right-2 flex items-center justify-center",
+                width: "16",
+                height: "16",
+                stroke: "currentColor",
+                "stroke-width": "1.5",
+                "stroke-linecap": "round",
+                "stroke-linejoin": "round",
+                viewBox: "0 0 16 16",
+                fill: "none",
+                xmlns: "http://www.w3.org/2000/svg",
+                children: l("path", {
+                  d: "M4 6.5L8 10.5L12 6.5"
+                })
+              })]
+            }) : l("input", {
+              autoFocus: u === 0 ? !0 : void 0,
+              class: "text-neutral-12 hover:bg-neutral-4 placeholder:text-neutral-8 focus:bg-neutral-5 flex-1 rounded-lg border-solid bg-transparent px-3 py-1.5 text-base transition-colors autofill:shadow-[inset_0_0_0_1000px_hsl(210_16.7%_97.6%)] focus:outline-none",
+              name: h,
+              id: c,
+              defaultValue: e[i],
+              required: !0
+            }), u === Rt.length - 1 ? l("hr", {
+              class: "m-0 w-full border-b border-b-transparent"
+            }) : l("hr", {
+              class: "border-b-neutral-5 m-0 w-full border-b border-solid"
+            })]
+          })]
+        }) : null;
+      })
+    }), l("div", {
+      class: "flex w-full flex-1 ",
+      children: [l("div", {
+        class: "flex-grow",
+        children: r
+      }), l(be, {
+        class: "flex items-center justify-center"
+      })]
+    })]
+  });
+}, yt = () => {
+  const e = re(null);
+  return ue(() => {
+    var t;
+    (t = e.current) == null || t.focus();
+  }, []), e;
+}, cr = ["true", "false"], Ln = Rr(cr), Nn = "answer", dr = "flex items-center gap-2 p-2.5", fr = sr(({
+  label: e,
+  ...t
+}, r) => l("button", {
+  class: "bg-lowest ease-expo-out ring-divider text-neutral-12 active:ring-accent-7 active:bg-accent-2 active:text-accent-11 fr block w-full overflow-hidden rounded-2xl px-2.5 py-2.5 ring-2 transition-all selection:bg-transparent",
+  ...t,
+  ref: r,
+  children: l("p", {
+    class: "truncate text-center text-base",
+    children: e
+  })
+})), Tn = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  const r = yt();
+  return l("form", {
+    noValidate: !0,
+    class: "",
+    onSubmit: (n) => {
+      n.preventDefault();
+      const s = Dr(n).value, a = ar(Ln, s);
+      t({
+        type: "boolean",
+        value: a === "true"
+      });
+    },
+    children: [l("ul", {
+      class: dr,
+      children: cr.map((n, s) => l("li", {
+        class: "flex-1",
+        children: l(fr, {
+          ref: s === 0 ? r : null,
+          type: "submit",
+          name: Nn,
+          value: n,
+          label: e.config.labels[n]
+        }, n)
+      }))
+    }), e.config.optional && l("div", {
+      class: "px-2 pb-2",
+      children: l(ve, {
+        class: "w-full",
+        type: "button",
+        onClick: () => t(null)
+      })
+    })]
+  });
+}, Dn = (e) => new Promise((t, r) => {
+  const n = new FileReader();
+  n.readAsDataURL(e), n.onload = () => n.result ? t(n.result.toString()) : r("No result from reader"), n.onerror = r;
+}), Rn = (e) => e.reduce((t, r) => t + r.sizeKb, 0), On = Se("file"), Bt = 3, Bn = ({
+  file: e,
+  class: t,
+  ...r
+}) => {
+  const n = e.name.split(".").pop(), s = e.name.replace(new RegExp(`.${n}$`), "");
+  return l("div", {
+    class: Ne("bg-accent-1 outline-accent-4 flex max-w-full gap-2 overflow-hidden rounded-lg px-3 py-2 text-sm outline", t),
+    ...r,
+    children: [l("p", {
+      "aria-label": "File name",
+      class: "text-accent-12 flex flex-grow overflow-hidden",
+      children: [l("span", {
+        class: "block truncate",
+        children: s
+      }), l("span", {
+        children: [".", n]
+      })]
+    }), l("p", {
+      "aria-label": "File size",
+      class: "text-accent-11",
+      children: Le(e.sizeKb)
+    })]
+  });
+}, Pt = ({
+  class: e,
+  ...t
+}) => l("li", {
+  class: Ne("outline-neutral-6 text-neutral-11 bg-neutral-1 block rounded-md px-1 py-0.5 text-xs outline outline-1", e),
+  ...t
+}), hr = (e) => {
+  const t = e.split(".").pop();
+  if (!t)
+    throw new Error("No file extension found");
+  return t ? "." + t : "";
+}, Pn = ({
+  allowedExtensions: e,
+  files: t
+}) => {
+  const r = e.map((n) => n.toLowerCase());
+  return t.every((n) => r.includes(hr(n.name).toLowerCase()));
+}, $n = (e, t) => {
+  const r = hr(e);
+  return `${e.replace(new RegExp(`${r}$`), "").slice(0, t)}${r}`;
+}, jn = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  var b;
+  const r = (b = M.current$.value.flow) == null ? void 0 : b.data.submissions[e.key], [n, s] = Y(On(r) ? r.value : []), [a, i] = Y(), u = n.length - Bt, c = Rn(n), h = yt(), {
+    t: x
+  } = Z();
+  return l("form", {
+    class: "flex flex-col gap-1 p-2.5",
+    onSubmit: (p) => (p.preventDefault(), i(void 0), n.length === 0 ? i({
+      type: "required",
+      message: x("validation_file")
+    }) : e.config.extensions.length > 0 && !Pn({
+      allowedExtensions: e.config.extensions,
+      files: n
+    }) ? i({
+      type: "validate",
+      message: `${x("validation_file_ext", {
+        ext: e.config.extensions.join(", ")
+      })}`
+    }) : e.config.fileSizeLimitKib && c > e.config.fileSizeLimitKib ? i({
+      type: "max",
+      message: `File size exceeds limit of ${Le(e.config.fileSizeLimitKib)}`
+    }) : e.config.allowMultiple === !1 && n.length > 1 ? i({
+      type: "invalid",
+      message: x("validation_file_max", {
+        count: 1
+      })
+    }) : t({
+      type: "file",
+      value: n
+    })),
+    children: [l("div", {
+      class: "flex items-center gap-2",
+      children: [l("label", {
+        ref: h,
+        for: "dropzone-file",
+        class: "border-neutral-8 bg-neutral-2 flex h-48 w-full cursor-pointer flex-col items-center justify-center overflow-hidden rounded-2xl border border-dashed p-4",
+        children: [n.length > 0 ? l(_e, {
+          children: [l("ul", {
+            class: "flex max-w-full flex-wrap justify-center gap-1 overflow-hidden p-1",
+            children: [n.slice(0, Bt).map((p) => {
+              const k = p.name.split(".").pop(), v = p.name.replace(new RegExp(`.${k}$`), "");
+              return l(Pt, {
+                class: "flex overflow-hidden",
+                children: [l("span", {
+                  class: "block truncate",
+                  children: v
+                }), l("span", {
+                  children: [".", k]
+                })]
+              });
+            }), u > 0 ? l(Pt, {
+              children: ["+", u, " file", u !== 1 ? "s" : ""]
+            }) : null]
+          }), l("p", {
+            class: "text-neutral-11 text-xs",
+            children: [Le(c), " ", n.length > 1 ? "total" : ""]
+          })]
+        }) : l("div", {
+          class: "flex flex-col justify-center gap-4 pb-6 pt-5",
+          children: [l("header", {
+            class: "flex flex-col items-center gap-0",
+            children: [l("svg", {
+              class: "text-neutral-11 mb-1 h-8 w-8",
+              "aria-hidden": "true",
+              xmlns: "http://www.w3.org/2000/svg",
+              fill: "none",
+              viewBox: "0 0 20 16",
+              children: l("path", {
+                stroke: "currentColor",
+                "stroke-linecap": "round",
+                "stroke-linejoin": "round",
+                "stroke-width": "1.5",
+                d: "M13 13h3a3 3 0 0 0 0-6h-.025A5.56 5.56 0 0 0 16 6.5 5.5 5.5 0 0 0 5.207 5.021C5.137 5.017 5.071 5 5 5a4 4 0 0 0 0 8h2.167M10 15V6m0 0L8 8m2-2 2 2"
+              })
+            }), l("p", {
+              class: "text-neutral-12 tracking-[-0.01em]",
+              children: x("upload_file", {
+                count: e.config.allowMultiple ? 2 : 1
+              })
+            }), e.config.fileSizeLimitKib ? l("p", {
+              class: "text-neutral-10 text-xs",
+              children: ["(", x("file_max_size", {
+                size: Le(e.config.fileSizeLimitKib)
+              }), ")"]
+            }) : null]
+          }), l("aside", {
+            class: "flex flex-col items-center gap-2",
+            children: [l("p", {
+              id: "accepted-filetypes",
+              class: "sr-only",
+              children: x("file_extensions")
+            }), l("ul", {
+              "aria-describedby": "accepted-filetypes",
+              class: "flex flex-wrap justify-center gap-2",
+              children: e.config.extensions.map((p) => l("li", {
+                class: "ring-lowest outline-neutral-6 text-neutral-9 bg-neutral-1 rounded-md px-1 py-0.5 text-[11px] uppercase tracking-wide outline outline-1 ring-2",
+                children: p.replace(".", "")
+              }))
+            })]
+          })]
+        }), l("input", {
+          id: "dropzone-file",
+          onInput: async (p) => {
+            le(p.target instanceof HTMLInputElement);
+            const k = p.target.files ? Array.from(p.target.files) : [], v = await Promise.allSettled(k.map(async (S) => {
+              const A = await Dn(S);
+              return {
+                name: $n(S.name, 42),
+                data: A,
+                sizeKb: S.size / 1e3
+              };
+            }));
+            if (v.some(({
+              status: S
+            }) => S === "rejected"))
+              return i({
+                type: "invalid",
+                message: "Invalid file"
+              });
+            const E = v.map((S) => S.status === "fulfilled" ? S.value : null).filter(Boolean);
+            s(E);
+          },
+          multiple: e.config.allowMultiple,
+          type: "file",
+          class: "sr-only"
+        })]
+      }), l("div", {
+        class: "flex h-full flex-col items-center gap-2",
+        children: [l(be, {
+          disabled: n.length === 0
+        }), e.config.optional && l(ve, {
+          onClick: () => t(null)
+        })]
+      })]
+    }), l(Ce, {
+      error: a
+    })]
+  });
+};
+var De = (e) => e.type === "checkbox", ke = (e) => e instanceof Date, U = (e) => e == null;
+const pr = (e) => typeof e == "object";
+var $ = (e) => !U(e) && !Array.isArray(e) && pr(e) && !ke(e), zn = (e) => $(e) && e.target ? De(e.target) ? e.target.checked : e.target.value : e, qn = (e) => e.substring(0, e.search(/\.\d+(\.|$)/)) || e, Un = (e, t) => e.has(qn(t)), Kn = (e) => {
+  const t = e.constructor && e.constructor.prototype;
+  return $(t) && t.hasOwnProperty("isPrototypeOf");
+}, bt = typeof window < "u" && typeof window.HTMLElement < "u" && typeof document < "u";
+function oe(e) {
+  let t;
+  const r = Array.isArray(e);
+  if (e instanceof Date)
+    t = new Date(e);
+  else if (e instanceof Set)
+    t = new Set(e);
+  else if (!(bt && (e instanceof Blob || e instanceof FileList)) && (r || $(e)))
+    if (t = r ? [] : {}, !r && !Kn(e))
+      t = e;
+    else
+      for (const n in e)
+        e.hasOwnProperty(n) && (t[n] = oe(e[n]));
+  else
+    return e;
+  return t;
+}
+var Re = (e) => Array.isArray(e) ? e.filter(Boolean) : [], O = (e) => e === void 0, w = (e, t, r) => {
+  if (!t || !$(e))
+    return r;
+  const n = Re(t.split(/[,[\].]+?/)).reduce((s, a) => U(s) ? s : s[a], e);
+  return O(n) || n === e ? O(e[t]) ? r : e[t] : n;
+}, de = (e) => typeof e == "boolean";
+const $t = {
+  BLUR: "blur",
+  FOCUS_OUT: "focusout",
+  CHANGE: "change"
+}, J = {
+  onBlur: "onBlur",
+  onChange: "onChange",
+  onSubmit: "onSubmit",
+  onTouched: "onTouched",
+  all: "all"
+}, ie = {
+  max: "max",
+  min: "min",
+  maxLength: "maxLength",
+  minLength: "minLength",
+  pattern: "pattern",
+  required: "required",
+  validate: "validate"
+};
+X.createContext(null);
+var Gn = (e, t, r, n = !0) => {
+  const s = {
+    defaultValues: t._defaultValues
+  };
+  for (const a in e)
+    Object.defineProperty(s, a, {
+      get: () => {
+        const i = a;
+        return t._proxyFormState[i] !== J.all && (t._proxyFormState[i] = !n || J.all), r && (r[i] = !0), e[i];
+      }
+    });
+  return s;
+}, W = (e) => $(e) && !Object.keys(e).length, Hn = (e, t, r, n) => {
+  r(e);
+  const { name: s, ...a } = e;
+  return W(a) || Object.keys(a).length >= Object.keys(t).length || Object.keys(a).find((i) => t[i] === (!n || J.all));
+}, it = (e) => Array.isArray(e) ? e : [e];
+function Wn(e) {
+  const t = X.useRef(e);
+  t.current = e, X.useEffect(() => {
+    const r = !e.disabled && t.current.subject && t.current.subject.subscribe({
+      next: t.current.next
+    });
+    return () => {
+      r && r.unsubscribe();
+    };
+  }, [e.disabled]);
+}
+var te = (e) => typeof e == "string", Jn = (e, t, r, n, s) => te(e) ? (n && t.watch.add(e), w(r, e, s)) : Array.isArray(e) ? e.map((a) => (n && t.watch.add(a), w(r, a))) : (n && (t.watchAll = !0), r), vt = (e) => /^\w*$/.test(e), mr = (e) => Re(e.replace(/["|']|\]/g, "").split(/\.|\[/));
+function L(e, t, r) {
+  let n = -1;
+  const s = vt(t) ? [t] : mr(t), a = s.length, i = a - 1;
+  for (; ++n < a; ) {
+    const u = s[n];
+    let c = r;
+    if (n !== i) {
+      const h = e[u];
+      c = $(h) || Array.isArray(h) ? h : isNaN(+s[n + 1]) ? {} : [];
+    }
+    e[u] = c, e = e[u];
+  }
+  return e;
+}
+var gr = (e, t, r, n, s) => t ? {
+  ...r[e],
+  types: {
+    ...r[e] && r[e].types ? r[e].types : {},
+    [n]: s || !0
+  }
+} : {}, jt = (e) => ({
+  isOnSubmit: !e || e === J.onSubmit,
+  isOnBlur: e === J.onBlur,
+  isOnChange: e === J.onChange,
+  isOnAll: e === J.all,
+  isOnTouch: e === J.onTouched
+}), zt = (e, t, r) => !r && (t.watchAll || t.watch.has(e) || [...t.watch].some((n) => e.startsWith(n) && /^\.\w+/.test(e.slice(n.length))));
+const ze = (e, t, r, n) => {
+  for (const s of r || Object.keys(e)) {
+    const a = w(e, s);
+    if (a) {
+      const { _f: i, ...u } = a;
+      if (i) {
+        if (i.refs && i.refs[0] && t(i.refs[0], s) && !n)
+          break;
+        if (i.ref && t(i.ref, i.name) && !n)
+          break;
+      } else
+        $(u) && ze(u, t);
+    }
+  }
+};
+var Zn = (e, t, r) => {
+  const n = Re(w(e, r));
+  return L(n, "root", t[r]), L(e, r, n), e;
+}, xt = (e) => e.type === "file", fe = (e) => typeof e == "function", Ge = (e) => {
+  if (!bt)
+    return !1;
+  const t = e ? e.ownerDocument : 0;
+  return e instanceof (t && t.defaultView ? t.defaultView.HTMLElement : HTMLElement);
+}, qe = (e) => te(e), wt = (e) => e.type === "radio", He = (e) => e instanceof RegExp;
+const qt = {
+  value: !1,
+  isValid: !1
+}, Ut = { value: !0, isValid: !0 };
+var yr = (e) => {
+  if (Array.isArray(e)) {
+    if (e.length > 1) {
+      const t = e.filter((r) => r && r.checked && !r.disabled).map((r) => r.value);
+      return { value: t, isValid: !!t.length };
+    }
+    return e[0].checked && !e[0].disabled ? (
+      // @ts-expect-error expected to work in the browser
+      e[0].attributes && !O(e[0].attributes.value) ? O(e[0].value) || e[0].value === "" ? Ut : { value: e[0].value, isValid: !0 } : Ut
+    ) : qt;
+  }
+  return qt;
+};
+const Kt = {
+  isValid: !1,
+  value: null
+};
+var br = (e) => Array.isArray(e) ? e.reduce((t, r) => r && r.checked && !r.disabled ? {
+  isValid: !0,
+  value: r.value
+} : t, Kt) : Kt;
+function Gt(e, t, r = "validate") {
+  if (qe(e) || Array.isArray(e) && e.every(qe) || de(e) && !e)
+    return {
+      type: r,
+      message: qe(e) ? e : "",
+      ref: t
+    };
+}
+var we = (e) => $(e) && !He(e) ? e : {
+  value: e,
+  message: ""
+}, Ht = async (e, t, r, n, s) => {
+  const { ref: a, refs: i, required: u, maxLength: c, minLength: h, min: x, max: b, pattern: p, validate: k, name: v, valueAsNumber: E, mount: S, disabled: A } = e._f, g = w(t, v);
+  if (!S || A)
+    return {};
+  const T = i ? i[0] : a, P = (F) => {
+    n && T.reportValidity && (T.setCustomValidity(de(F) ? "" : F || ""), T.reportValidity());
+  }, D = {}, me = wt(a), ce = De(a), Ae = me || ce, G = (E || xt(a)) && O(a.value) && O(g) || Ge(a) && a.value === "" || g === "" || Array.isArray(g) && !g.length, se = gr.bind(null, v, r, D), q = (F, V, R, K = ie.maxLength, H = ie.minLength) => {
+    const Q = F ? V : R;
+    D[v] = {
+      type: F ? K : H,
+      message: Q,
+      ref: a,
+      ...se(F ? K : H, Q)
+    };
+  };
+  if (s ? !Array.isArray(g) || !g.length : u && (!Ae && (G || U(g)) || de(g) && !g || ce && !yr(i).isValid || me && !br(i).isValid)) {
+    const { value: F, message: V } = qe(u) ? { value: !!u, message: u } : we(u);
+    if (F && (D[v] = {
+      type: ie.required,
+      message: V,
+      ref: T,
+      ...se(ie.required, V)
+    }, !r))
+      return P(V), D;
+  }
+  if (!G && (!U(x) || !U(b))) {
+    let F, V;
+    const R = we(b), K = we(x);
+    if (!U(g) && !isNaN(g)) {
+      const H = a.valueAsNumber || g && +g;
+      U(R.value) || (F = H > R.value), U(K.value) || (V = H < K.value);
+    } else {
+      const H = a.valueAsDate || new Date(g), Q = (Oe) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + Oe), ge = a.type == "time", Ee = a.type == "week";
+      te(R.value) && g && (F = ge ? Q(g) > Q(R.value) : Ee ? g > R.value : H > new Date(R.value)), te(K.value) && g && (V = ge ? Q(g) < Q(K.value) : Ee ? g < K.value : H < new Date(K.value));
+    }
+    if ((F || V) && (q(!!F, R.message, K.message, ie.max, ie.min), !r))
+      return P(D[v].message), D;
+  }
+  if ((c || h) && !G && (te(g) || s && Array.isArray(g))) {
+    const F = we(c), V = we(h), R = !U(F.value) && g.length > +F.value, K = !U(V.value) && g.length < +V.value;
+    if ((R || K) && (q(R, F.message, V.message), !r))
+      return P(D[v].message), D;
+  }
+  if (p && !G && te(g)) {
+    const { value: F, message: V } = we(p);
+    if (He(F) && !g.match(F) && (D[v] = {
+      type: ie.pattern,
+      message: V,
+      ref: a,
+      ...se(ie.pattern, V)
+    }, !r))
+      return P(V), D;
+  }
+  if (k) {
+    if (fe(k)) {
+      const F = await k(g, t), V = Gt(F, T);
+      if (V && (D[v] = {
+        ...V,
+        ...se(ie.validate, V.message)
+      }, !r))
+        return P(V.message), D;
+    } else if ($(k)) {
+      let F = {};
+      for (const V in k) {
+        if (!W(F) && !r)
+          break;
+        const R = Gt(await k[V](g, t), T, V);
+        R && (F = {
+          ...R,
+          ...se(V, R.message)
+        }, P(R.message), r && (D[v] = F));
+      }
+      if (!W(F) && (D[v] = {
+        ref: T,
+        ...F
+      }, !r))
+        return D;
+    }
+  }
+  return P(!0), D;
+};
+function Qn(e, t) {
+  const r = t.slice(0, -1).length;
+  let n = 0;
+  for (; n < r; )
+    e = O(e) ? n++ : e[t[n++]];
+  return e;
+}
+function Xn(e) {
+  for (const t in e)
+    if (e.hasOwnProperty(t) && !O(e[t]))
+      return !1;
+  return !0;
+}
+function j(e, t) {
+  const r = Array.isArray(t) ? t : vt(t) ? [t] : mr(t), n = r.length === 1 ? e : Qn(e, r), s = r.length - 1, a = r[s];
+  return n && delete n[a], s !== 0 && ($(n) && W(n) || Array.isArray(n) && Xn(n)) && j(e, r.slice(0, -1)), e;
+}
+function ot() {
+  let e = [];
+  return {
+    get observers() {
+      return e;
+    },
+    next: (s) => {
+      for (const a of e)
+        a.next && a.next(s);
+    },
+    subscribe: (s) => (e.push(s), {
+      unsubscribe: () => {
+        e = e.filter((a) => a !== s);
+      }
+    }),
+    unsubscribe: () => {
+      e = [];
+    }
+  };
+}
+var We = (e) => U(e) || !pr(e);
+function ye(e, t) {
+  if (We(e) || We(t))
+    return e === t;
+  if (ke(e) && ke(t))
+    return e.getTime() === t.getTime();
+  const r = Object.keys(e), n = Object.keys(t);
+  if (r.length !== n.length)
+    return !1;
+  for (const s of r) {
+    const a = e[s];
+    if (!n.includes(s))
+      return !1;
+    if (s !== "ref") {
+      const i = t[s];
+      if (ke(a) && ke(i) || $(a) && $(i) || Array.isArray(a) && Array.isArray(i) ? !ye(a, i) : a !== i)
+        return !1;
+    }
+  }
+  return !0;
+}
+var vr = (e) => e.type === "select-multiple", Yn = (e) => wt(e) || De(e), lt = (e) => Ge(e) && e.isConnected, xr = (e) => {
+  for (const t in e)
+    if (fe(e[t]))
+      return !0;
+  return !1;
+};
+function Je(e, t = {}) {
+  const r = Array.isArray(e);
+  if ($(e) || r)
+    for (const n in e)
+      Array.isArray(e[n]) || $(e[n]) && !xr(e[n]) ? (t[n] = Array.isArray(e[n]) ? [] : {}, Je(e[n], t[n])) : U(e[n]) || (t[n] = !0);
+  return t;
+}
+function wr(e, t, r) {
+  const n = Array.isArray(e);
+  if ($(e) || n)
+    for (const s in e)
+      Array.isArray(e[s]) || $(e[s]) && !xr(e[s]) ? O(t) || We(r[s]) ? r[s] = Array.isArray(e[s]) ? Je(e[s], []) : { ...Je(e[s]) } : wr(e[s], U(t) ? {} : t[s], r[s]) : r[s] = !ye(e[s], t[s]);
+  return r;
+}
+var ut = (e, t) => wr(e, t, Je(t)), kr = (e, { valueAsNumber: t, valueAsDate: r, setValueAs: n }) => O(e) ? e : t ? e === "" ? NaN : e && +e : r && te(e) ? new Date(e) : n ? n(e) : e;
+function ct(e) {
+  const t = e.ref;
+  if (!(e.refs ? e.refs.every((r) => r.disabled) : t.disabled))
+    return xt(t) ? t.files : wt(t) ? br(e.refs).value : vr(t) ? [...t.selectedOptions].map(({ value: r }) => r) : De(t) ? yr(e.refs).value : kr(O(t.value) ? e.ref.value : t.value, e);
+}
+var es = (e, t, r, n) => {
+  const s = {};
+  for (const a of e) {
+    const i = w(t, a);
+    i && L(s, a, i._f);
+  }
+  return {
+    criteriaMode: r,
+    names: [...e],
+    fields: s,
+    shouldUseNativeValidation: n
+  };
+}, Ve = (e) => O(e) ? e : He(e) ? e.source : $(e) ? He(e.value) ? e.value.source : e.value : e, ts = (e) => e.mount && (e.required || e.min || e.max || e.maxLength || e.minLength || e.pattern || e.validate);
+function Wt(e, t, r) {
+  const n = w(e, r);
+  if (n || vt(r))
+    return {
+      error: n,
+      name: r
+    };
+  const s = r.split(".");
+  for (; s.length; ) {
+    const a = s.join("."), i = w(t, a), u = w(e, a);
+    if (i && !Array.isArray(i) && r !== a)
+      return { name: r };
+    if (u && u.type)
+      return {
+        name: a,
+        error: u
+      };
+    s.pop();
+  }
+  return {
+    name: r
+  };
+}
+var rs = (e, t, r, n, s) => s.isOnAll ? !1 : !r && s.isOnTouch ? !(t || e) : (r ? n.isOnBlur : s.isOnBlur) ? !e : (r ? n.isOnChange : s.isOnChange) ? e : !0, ns = (e, t) => !Re(w(e, t)).length && j(e, t);
+const ss = {
+  mode: J.onSubmit,
+  reValidateMode: J.onChange,
+  shouldFocusError: !0
+};
+function as(e = {}, t) {
+  let r = {
+    ...ss,
+    ...e
+  }, n = {
+    submitCount: 0,
+    isDirty: !1,
+    isLoading: fe(r.defaultValues),
+    isValidating: !1,
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    touchedFields: {},
+    dirtyFields: {},
+    errors: {},
+    disabled: !1
+  }, s = {}, a = $(r.defaultValues) || $(r.values) ? oe(r.defaultValues || r.values) || {} : {}, i = r.shouldUnregister ? {} : oe(a), u = {
+    action: !1,
+    mount: !1,
+    watch: !1
+  }, c = {
+    mount: /* @__PURE__ */ new Set(),
+    unMount: /* @__PURE__ */ new Set(),
+    array: /* @__PURE__ */ new Set(),
+    watch: /* @__PURE__ */ new Set()
+  }, h, x = 0;
+  const b = {
+    isDirty: !1,
+    dirtyFields: !1,
+    touchedFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  }, p = {
+    values: ot(),
+    array: ot(),
+    state: ot()
+  }, k = e.resetOptions && e.resetOptions.keepDirtyValues, v = jt(r.mode), E = jt(r.reValidateMode), S = r.criteriaMode === J.all, A = (o) => (d) => {
+    clearTimeout(x), x = setTimeout(o, d);
+  }, g = async (o) => {
+    if (b.isValid || o) {
+      const d = r.resolver ? W((await G()).errors) : await q(s, !0);
+      d !== n.isValid && p.state.next({
+        isValid: d
+      });
+    }
+  }, T = (o) => b.isValidating && p.state.next({
+    isValidating: o
+  }), P = (o, d = [], f, _, y = !0, m = !0) => {
+    if (_ && f) {
+      if (u.action = !0, m && Array.isArray(w(s, o))) {
+        const C = f(w(s, o), _.argA, _.argB);
+        y && L(s, o, C);
+      }
+      if (m && Array.isArray(w(n.errors, o))) {
+        const C = f(w(n.errors, o), _.argA, _.argB);
+        y && L(n.errors, o, C), ns(n.errors, o);
+      }
+      if (b.touchedFields && m && Array.isArray(w(n.touchedFields, o))) {
+        const C = f(w(n.touchedFields, o), _.argA, _.argB);
+        y && L(n.touchedFields, o, C);
+      }
+      b.dirtyFields && (n.dirtyFields = ut(a, i)), p.state.next({
+        name: o,
+        isDirty: V(o, d),
+        dirtyFields: n.dirtyFields,
+        errors: n.errors,
+        isValid: n.isValid
+      });
+    } else
+      L(i, o, d);
+  }, D = (o, d) => {
+    L(n.errors, o, d), p.state.next({
+      errors: n.errors
+    });
+  }, me = (o, d, f, _) => {
+    const y = w(s, o);
+    if (y) {
+      const m = w(i, o, O(f) ? w(a, o) : f);
+      O(m) || _ && _.defaultChecked || d ? L(i, o, d ? m : ct(y._f)) : H(o, m), u.mount && g();
+    }
+  }, ce = (o, d, f, _, y) => {
+    let m = !1, C = !1;
+    const N = {
+      name: o
+    };
+    if (!f || _) {
+      b.isDirty && (C = n.isDirty, n.isDirty = N.isDirty = V(), m = C !== N.isDirty);
+      const B = ye(w(a, o), d);
+      C = w(n.dirtyFields, o), B ? j(n.dirtyFields, o) : L(n.dirtyFields, o, !0), N.dirtyFields = n.dirtyFields, m = m || b.dirtyFields && C !== !B;
+    }
+    if (f) {
+      const B = w(n.touchedFields, o);
+      B || (L(n.touchedFields, o, f), N.touchedFields = n.touchedFields, m = m || b.touchedFields && B !== f);
+    }
+    return m && y && p.state.next(N), m ? N : {};
+  }, Ae = (o, d, f, _) => {
+    const y = w(n.errors, o), m = b.isValid && de(d) && n.isValid !== d;
+    if (e.delayError && f ? (h = A(() => D(o, f)), h(e.delayError)) : (clearTimeout(x), h = null, f ? L(n.errors, o, f) : j(n.errors, o)), (f ? !ye(y, f) : y) || !W(_) || m) {
+      const C = {
+        ..._,
+        ...m && de(d) ? { isValid: d } : {},
+        errors: n.errors,
+        name: o
+      };
+      n = {
+        ...n,
+        ...C
+      }, p.state.next(C);
+    }
+    T(!1);
+  }, G = async (o) => r.resolver(i, r.context, es(o || c.mount, s, r.criteriaMode, r.shouldUseNativeValidation)), se = async (o) => {
+    const { errors: d } = await G(o);
+    if (o)
+      for (const f of o) {
+        const _ = w(d, f);
+        _ ? L(n.errors, f, _) : j(n.errors, f);
+      }
+    else
+      n.errors = d;
+    return d;
+  }, q = async (o, d, f = {
+    valid: !0
+  }) => {
+    for (const _ in o) {
+      const y = o[_];
+      if (y) {
+        const { _f: m, ...C } = y;
+        if (m) {
+          const N = c.array.has(m.name), B = await Ht(y, i, S, r.shouldUseNativeValidation && !d, N);
+          if (B[m.name] && (f.valid = !1, d))
+            break;
+          !d && (w(B, m.name) ? N ? Zn(n.errors, B, m.name) : L(n.errors, m.name, B[m.name]) : j(n.errors, m.name));
+        }
+        C && await q(C, d, f);
+      }
+    }
+    return f.valid;
+  }, F = () => {
+    for (const o of c.unMount) {
+      const d = w(s, o);
+      d && (d._f.refs ? d._f.refs.every((f) => !lt(f)) : !lt(d._f.ref)) && tt(o);
+    }
+    c.unMount = /* @__PURE__ */ new Set();
+  }, V = (o, d) => (o && d && L(i, o, d), !ye(kt(), a)), R = (o, d, f) => Jn(o, c, {
+    ...u.mount ? i : O(d) ? a : te(o) ? { [o]: d } : d
+  }, f, d), K = (o) => Re(w(u.mount ? i : a, o, e.shouldUnregister ? w(a, o, []) : [])), H = (o, d, f = {}) => {
+    const _ = w(s, o);
+    let y = d;
+    if (_) {
+      const m = _._f;
+      m && (!m.disabled && L(i, o, kr(d, m)), y = Ge(m.ref) && U(d) ? "" : d, vr(m.ref) ? [...m.ref.options].forEach((C) => C.selected = y.includes(C.value)) : m.refs ? De(m.ref) ? m.refs.length > 1 ? m.refs.forEach((C) => (!C.defaultChecked || !C.disabled) && (C.checked = Array.isArray(y) ? !!y.find((N) => N === C.value) : y === C.value)) : m.refs[0] && (m.refs[0].checked = !!y) : m.refs.forEach((C) => C.checked = C.value === y) : xt(m.ref) ? m.ref.value = "" : (m.ref.value = y, m.ref.type || p.values.next({
+        name: o,
+        values: { ...i }
+      })));
+    }
+    (f.shouldDirty || f.shouldTouch) && ce(o, y, f.shouldTouch, f.shouldDirty, !0), f.shouldValidate && et(o);
+  }, Q = (o, d, f) => {
+    for (const _ in d) {
+      const y = d[_], m = `${o}.${_}`, C = w(s, m);
+      (c.array.has(o) || !We(y) || C && !C._f) && !ke(y) ? Q(m, y, f) : H(m, y, f);
+    }
+  }, ge = (o, d, f = {}) => {
+    const _ = w(s, o), y = c.array.has(o), m = oe(d);
+    L(i, o, m), y ? (p.array.next({
+      name: o,
+      values: { ...i }
+    }), (b.isDirty || b.dirtyFields) && f.shouldDirty && p.state.next({
+      name: o,
+      dirtyFields: ut(a, i),
+      isDirty: V(o, m)
+    })) : _ && !_._f && !U(m) ? Q(o, m, f) : H(o, m, f), zt(o, c) && p.state.next({ ...n }), p.values.next({
+      name: o,
+      values: { ...i }
+    }), !u.mount && t();
+  }, Ee = async (o) => {
+    const d = o.target;
+    let f = d.name, _ = !0;
+    const y = w(s, f), m = () => d.type ? ct(y._f) : zn(o), C = (N) => {
+      _ = Number.isNaN(N) || N === w(i, f, N);
+    };
+    if (y) {
+      let N, B;
+      const Be = m(), xe = o.type === $t.BLUR || o.type === $t.FOCUS_OUT, Ir = !ts(y._f) && !r.resolver && !w(n.errors, f) && !y._f.deps || rs(xe, w(n.touchedFields, f), n.isSubmitted, E, v), nt = zt(f, c, xe);
+      L(i, f, Be), xe ? (y._f.onBlur && y._f.onBlur(o), h && h(0)) : y._f.onChange && y._f.onChange(o);
+      const st = ce(f, Be, xe, !1), Vr = !W(st) || nt;
+      if (!xe && p.values.next({
+        name: f,
+        type: o.type,
+        values: { ...i }
+      }), Ir)
+        return b.isValid && g(), Vr && p.state.next({ name: f, ...nt ? {} : st });
+      if (!xe && nt && p.state.next({ ...n }), T(!0), r.resolver) {
+        const { errors: Mt } = await G([f]);
+        if (C(Be), _) {
+          const Mr = Wt(n.errors, s, f), Ft = Wt(Mt, s, Mr.name || f);
+          N = Ft.error, f = Ft.name, B = W(Mt);
+        }
+      } else
+        N = (await Ht(y, i, S, r.shouldUseNativeValidation))[f], C(Be), _ && (N ? B = !1 : b.isValid && (B = await q(s, !0)));
+      _ && (y._f.deps && et(y._f.deps), Ae(f, B, N, st));
+    }
+  }, Oe = (o, d) => {
+    if (w(n.errors, d) && o.focus)
+      return o.focus(), 1;
+  }, et = async (o, d = {}) => {
+    let f, _;
+    const y = it(o);
+    if (T(!0), r.resolver) {
+      const m = await se(O(o) ? o : y);
+      f = W(m), _ = o ? !y.some((C) => w(m, C)) : f;
+    } else
+      o ? (_ = (await Promise.all(y.map(async (m) => {
+        const C = w(s, m);
+        return await q(C && C._f ? { [m]: C } : C);
+      }))).every(Boolean), !(!_ && !n.isValid) && g()) : _ = f = await q(s);
+    return p.state.next({
+      ...!te(o) || b.isValid && f !== n.isValid ? {} : { name: o },
+      ...r.resolver || !o ? { isValid: f } : {},
+      errors: n.errors,
+      isValidating: !1
+    }), d.shouldFocus && !_ && ze(s, Oe, o ? y : c.mount), _;
+  }, kt = (o) => {
+    const d = {
+      ...a,
+      ...u.mount ? i : {}
+    };
+    return O(o) ? d : te(o) ? w(d, o) : o.map((f) => w(d, f));
+  }, _t = (o, d) => ({
+    invalid: !!w((d || n).errors, o),
+    isDirty: !!w((d || n).dirtyFields, o),
+    isTouched: !!w((d || n).touchedFields, o),
+    error: w((d || n).errors, o)
+  }), Sr = (o) => {
+    o && it(o).forEach((d) => j(n.errors, d)), p.state.next({
+      errors: o ? n.errors : {}
+    });
+  }, St = (o, d, f) => {
+    const _ = (w(s, o, { _f: {} })._f || {}).ref;
+    L(n.errors, o, {
+      ...d,
+      ref: _
+    }), p.state.next({
+      name: o,
+      errors: n.errors,
+      isValid: !1
+    }), f && f.shouldFocus && _ && _.focus && _.focus();
+  }, Cr = (o, d) => fe(o) ? p.values.subscribe({
+    next: (f) => o(R(void 0, d), f)
+  }) : R(o, d, !0), tt = (o, d = {}) => {
+    for (const f of o ? it(o) : c.mount)
+      c.mount.delete(f), c.array.delete(f), d.keepValue || (j(s, f), j(i, f)), !d.keepError && j(n.errors, f), !d.keepDirty && j(n.dirtyFields, f), !d.keepTouched && j(n.touchedFields, f), !r.shouldUnregister && !d.keepDefaultValue && j(a, f);
+    p.values.next({
+      values: { ...i }
+    }), p.state.next({
+      ...n,
+      ...d.keepDirty ? { isDirty: V() } : {}
+    }), !d.keepIsValid && g();
+  }, Ct = ({ disabled: o, name: d, field: f, fields: _, value: y }) => {
+    if (de(o)) {
+      const m = o ? void 0 : O(y) ? ct(f ? f._f : w(_, d)._f) : y;
+      L(i, d, m), ce(d, m, !1, !1, !0);
+    }
+  }, rt = (o, d = {}) => {
+    let f = w(s, o);
+    const _ = de(d.disabled);
+    return L(s, o, {
+      ...f || {},
+      _f: {
+        ...f && f._f ? f._f : { ref: { name: o } },
+        name: o,
+        mount: !0,
+        ...d
+      }
+    }), c.mount.add(o), f ? Ct({
+      field: f,
+      disabled: d.disabled,
+      name: o
+    }) : me(o, !0, d.value), {
+      ..._ ? { disabled: d.disabled } : {},
+      ...r.progressive ? {
+        required: !!d.required,
+        min: Ve(d.min),
+        max: Ve(d.max),
+        minLength: Ve(d.minLength),
+        maxLength: Ve(d.maxLength),
+        pattern: Ve(d.pattern)
+      } : {},
+      name: o,
+      onChange: Ee,
+      onBlur: Ee,
+      ref: (y) => {
+        if (y) {
+          rt(o, d), f = w(s, o);
+          const m = O(y.value) && y.querySelectorAll && y.querySelectorAll("input,select,textarea")[0] || y, C = Yn(m), N = f._f.refs || [];
+          if (C ? N.find((B) => B === m) : m === f._f.ref)
+            return;
+          L(s, o, {
+            _f: {
+              ...f._f,
+              ...C ? {
+                refs: [
+                  ...N.filter(lt),
+                  m,
+                  ...Array.isArray(w(a, o)) ? [{}] : []
+                ],
+                ref: { type: m.type, name: o }
+              } : { ref: m }
+            }
+          }), me(o, !1, void 0, m);
+        } else
+          f = w(s, o, {}), f._f && (f._f.mount = !1), (r.shouldUnregister || d.shouldUnregister) && !(Un(c.array, o) && u.action) && c.unMount.add(o);
+      }
+    };
+  }, At = () => r.shouldFocusError && ze(s, Oe, c.mount), Ar = (o) => {
+    de(o) && (p.state.next({ disabled: o }), ze(s, (d) => {
+      d.disabled = o;
+    }, 0, !1));
+  }, Et = (o, d) => async (f) => {
+    f && (f.preventDefault && f.preventDefault(), f.persist && f.persist());
+    let _ = oe(i);
+    if (p.state.next({
+      isSubmitting: !0
+    }), r.resolver) {
+      const { errors: y, values: m } = await G();
+      n.errors = y, _ = m;
+    } else
+      await q(s);
+    j(n.errors, "root"), W(n.errors) ? (p.state.next({
+      errors: {}
+    }), await o(_, f)) : (d && await d({ ...n.errors }, f), At(), setTimeout(At)), p.state.next({
+      isSubmitted: !0,
+      isSubmitting: !1,
+      isSubmitSuccessful: W(n.errors),
+      submitCount: n.submitCount + 1,
+      errors: n.errors
+    });
+  }, Er = (o, d = {}) => {
+    w(s, o) && (O(d.defaultValue) ? ge(o, w(a, o)) : (ge(o, d.defaultValue), L(a, o, d.defaultValue)), d.keepTouched || j(n.touchedFields, o), d.keepDirty || (j(n.dirtyFields, o), n.isDirty = d.defaultValue ? V(o, w(a, o)) : V()), d.keepError || (j(n.errors, o), b.isValid && g()), p.state.next({ ...n }));
+  }, It = (o, d = {}) => {
+    const f = o ? oe(o) : a, _ = oe(f), y = o && !W(o) ? _ : a;
+    if (d.keepDefaultValues || (a = f), !d.keepValues) {
+      if (d.keepDirtyValues || k)
+        for (const m of c.mount)
+          w(n.dirtyFields, m) ? L(y, m, w(i, m)) : ge(m, w(y, m));
+      else {
+        if (bt && O(o))
+          for (const m of c.mount) {
+            const C = w(s, m);
+            if (C && C._f) {
+              const N = Array.isArray(C._f.refs) ? C._f.refs[0] : C._f.ref;
+              if (Ge(N)) {
+                const B = N.closest("form");
+                if (B) {
+                  B.reset();
+                  break;
+                }
+              }
+            }
+          }
+        s = {};
+      }
+      i = e.shouldUnregister ? d.keepDefaultValues ? oe(a) : {} : oe(y), p.array.next({
+        values: { ...y }
+      }), p.values.next({
+        values: { ...y }
+      });
+    }
+    c = {
+      mount: /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: !1,
+      focus: ""
+    }, !u.mount && t(), u.mount = !b.isValid || !!d.keepIsValid, u.watch = !!e.shouldUnregister, p.state.next({
+      submitCount: d.keepSubmitCount ? n.submitCount : 0,
+      isDirty: d.keepDirty ? n.isDirty : !!(d.keepDefaultValues && !ye(o, a)),
+      isSubmitted: d.keepIsSubmitted ? n.isSubmitted : !1,
+      dirtyFields: d.keepDirtyValues ? n.dirtyFields : d.keepDefaultValues && o ? ut(a, o) : {},
+      touchedFields: d.keepTouched ? n.touchedFields : {},
+      errors: d.keepErrors ? n.errors : {},
+      isSubmitSuccessful: d.keepIsSubmitSuccessful ? n.isSubmitSuccessful : !1,
+      isSubmitting: !1
+    });
+  }, Vt = (o, d) => It(fe(o) ? o(i) : o, d);
+  return {
+    control: {
+      register: rt,
+      unregister: tt,
+      getFieldState: _t,
+      handleSubmit: Et,
+      setError: St,
+      _executeSchema: G,
+      _getWatch: R,
+      _getDirty: V,
+      _updateValid: g,
+      _removeUnmounted: F,
+      _updateFieldArray: P,
+      _updateDisabledField: Ct,
+      _getFieldArray: K,
+      _reset: It,
+      _resetDefaultValues: () => fe(r.defaultValues) && r.defaultValues().then((o) => {
+        Vt(o, r.resetOptions), p.state.next({
+          isLoading: !1
+        });
+      }),
+      _updateFormState: (o) => {
+        n = {
+          ...n,
+          ...o
+        };
+      },
+      _disableForm: Ar,
+      _subjects: p,
+      _proxyFormState: b,
+      get _fields() {
+        return s;
+      },
+      get _formValues() {
+        return i;
+      },
+      get _state() {
+        return u;
+      },
+      set _state(o) {
+        u = o;
+      },
+      get _defaultValues() {
+        return a;
+      },
+      get _names() {
+        return c;
+      },
+      set _names(o) {
+        c = o;
+      },
+      get _formState() {
+        return n;
+      },
+      set _formState(o) {
+        n = o;
+      },
+      get _options() {
+        return r;
+      },
+      set _options(o) {
+        r = {
+          ...r,
+          ...o
+        };
+      }
+    },
+    trigger: et,
+    register: rt,
+    handleSubmit: Et,
+    watch: Cr,
+    setValue: ge,
+    getValues: kt,
+    reset: Vt,
+    resetField: Er,
+    clearErrors: Sr,
+    unregister: tt,
+    setError: St,
+    setFocus: (o, d = {}) => {
+      const f = w(s, o), _ = f && f._f;
+      if (_) {
+        const y = _.refs ? _.refs[0] : _.ref;
+        y.focus && (y.focus(), d.shouldSelect && y.select());
+      }
+    },
+    getFieldState: _t
+  };
+}
+function Xe(e = {}) {
+  const t = X.useRef(), r = X.useRef(), [n, s] = X.useState({
+    isDirty: !1,
+    isValidating: !1,
+    isLoading: fe(e.defaultValues),
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    errors: {},
+    disabled: !1,
+    defaultValues: fe(e.defaultValues) ? void 0 : e.defaultValues
+  });
+  t.current || (t.current = {
+    ...as(e, () => s((i) => ({ ...i }))),
+    formState: n
+  });
+  const a = t.current.control;
+  return a._options = e, Wn({
+    subject: a._subjects.state,
+    next: (i) => {
+      Hn(i, a._proxyFormState, a._updateFormState, !0) && s({ ...a._formState });
+    }
+  }), X.useEffect(() => a._disableForm(e.disabled), [a, e.disabled]), X.useEffect(() => {
+    if (a._proxyFormState.isDirty) {
+      const i = a._getDirty();
+      i !== n.isDirty && a._subjects.state.next({
+        isDirty: i
+      });
+    }
+  }, [a, n.isDirty]), X.useEffect(() => {
+    e.values && !ye(e.values, r.current) ? (a._reset(e.values, a._options.resetOptions), r.current = e.values) : a._resetDefaultValues();
+  }, [e.values, a]), X.useEffect(() => {
+    a._state.mount || (a._updateValid(), a._state.mount = !0), a._state.watch && (a._state.watch = !1, a._subjects.state.next({ ...a._formState })), a._removeUnmounted();
+  }), t.current.formState = Gn(n, a), t.current;
+}
+var Jt = function(e, t, r) {
+  if (e && "reportValidity" in e) {
+    var n = w(r, t);
+    e.setCustomValidity(n && n.message || ""), e.reportValidity();
+  }
+}, is = function(e, t) {
+  var r = function(s) {
+    var a = t.fields[s];
+    a && a.ref && "reportValidity" in a.ref ? Jt(a.ref, s, e) : a.refs && a.refs.forEach(function(i) {
+      return Jt(i, s, e);
+    });
+  };
+  for (var n in t.fields)
+    r(n);
+}, os = function(e, t) {
+  t.shouldUseNativeValidation && is(e, t);
+  var r = {};
+  for (var n in e) {
+    var s = w(t.fields, n), a = Object.assign(e[n] || {}, { ref: s && s.ref });
+    if (us(t.names || Object.keys(e), n)) {
+      var i = Object.assign({}, ls(w(r, n)));
+      L(i, "root", a), L(r, n, i);
+    } else
+      L(r, n, a);
+  }
+  return r;
+}, ls = function(e) {
+  return Array.isArray(e) ? e.filter(Boolean) : [];
+}, us = function(e, t) {
+  return e.some(function(r) {
+    return r.startsWith(t + ".");
+  });
+}, cs = function(e, t) {
+  for (var r = {}; e.issues.length; ) {
+    var n = e.issues[0];
+    if (n.path) {
+      var s = n.path.map(function(u) {
+        return u.key;
+      }).join(".");
+      if (r[s] || (r[s] = { message: n.message, type: n.validation }), t) {
+        var a = r[s].types, i = a && a[n.validation];
+        r[s] = gr(s, t, r, n.validation, i ? [].concat(i, n.message) : n.message);
+      }
+      e.issues.shift();
+    }
+  }
+  return r;
+}, Ye = function(e, t, r) {
+  return r === void 0 && (r = {}), function(n, s, a) {
+    try {
+      return Promise.resolve(function(i, u) {
+        try {
+          var c = function() {
+            function h(b) {
+              return { values: r.raw ? n : b, errors: {} };
+            }
+            var x = Object.assign({}, { abortEarly: !1, abortPipeEarly: !1 }, t);
+            return r.mode === "sync" ? h(ar(e, n, x)) : Promise.resolve(Or(e, n, x)).then(h);
+          }();
+        } catch (h) {
+          return u(h);
+        }
+        return c && c.then ? c.then(void 0, u) : c;
+      }(0, function(i) {
+        if (i instanceof Br)
+          return { values: {}, errors: os(cs(i, !a.shouldUseNativeValidation && a.criteriaMode === "all"), a) };
+        throw i;
+      }));
+    } catch (i) {
+      return Promise.reject(i);
+    }
+  };
+};
+const Zt = 27, Qt = 12, Xt = 10, ds = Se("enum"), fs = (e) => {
+  const t = {
+    min: e.minSelected ?? 0,
+    max: e.maxSelected ?? e.options.length
+  };
+  return Ye(he({
+    checked: ir(Pr($r()), (r) => Object.entries(r).filter(([n, s]) => s).map(([n, s]) => n), [$e(t.max, `Please select at most ${t.max} option${t.max !== 1 ? "s" : ""}`), je(t.min, `Please select at least ${t.min} option${t.min !== 1 ? "s" : ""}`)])
+  }));
+}, hs = sr(({
+  option: e,
+  ...t
+}, r) => l(_e, {
+  children: [l("input", {
+    class: "peer sr-only h-full",
+    type: "checkbox",
+    ...t,
+    ref: r
+  }), l("label", {
+    class: "bg-lowest hover:bg-neutral-2 active:outline-neutral-8 ease-expo-out outline-divider text-neutral-11 peer-checked:outline-accent-7 peer-checked:bg-accent-2 peer-checked:text-accent-9 peer-focus-visible:ring-accent-9 peer-focus-visible:ring-offset-accent-7 block cursor-pointer select-none rounded-2xl px-3 py-1.5 outline outline-1 ring-0 ring-transparent transition-all selection:bg-transparent peer-focus-visible:ring-4",
+    htmlFor: t.id,
+    children: e.label
+  })]
+})), Yt = Ze("gutter-stable flex w-full flex-1 flex-wrap gap-3 overflow-y-auto rounded-xl p-2.5 pr-4", {
+  variants: {
+    variant: {
+      // In cases where there is only one option, we want to center it
+      singleOption: "justify-center",
+      // Two choices with exactly 1 min 1 max
+      booleanLike: dr
+    }
+  }
+}), ps = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  var h, x;
+  const r = e.key ? (h = M.current$.value.flow) == null ? void 0 : h.data.submissions[e.key] : void 0, n = (e.config.minSelected === 1 || e.config.minSelected === void 0) && e.config.maxSelected === 1, s = n && e.config.options.length === 2, {
+    register: a,
+    handleSubmit: i,
+    formState: {
+      errors: u
+    }
+  } = Xe({
+    defaultValues: {
+      checked: n ? {} : ds(r) ? Object.fromEntries(r.value.map((b) => [b, !0])) : {}
+    },
+    resolver: fs(e.config)
+  }), c = yt();
+  return s ? l("ul", {
+    style: {
+      maxHeight: 6.5 * Zt + 5 * Qt + 2 * Xt
+    },
+    class: Yt({
+      variant: "booleanLike"
+    }),
+    children: e.config.options.map((b, p) => l("li", {
+      class: "flex-1",
+      children: l(fr, {
+        type: "submit",
+        ref: (k) => {
+          k && p === 0 && (c.current = k);
+        },
+        label: b.label,
+        value: "true",
+        onClick: () => t({
+          type: "enum",
+          value: [b.value]
+        })
+      })
+    }, b.value))
+  }) : l("form", {
+    noValidate: !0,
+    onSubmit: (b) => i((p) => {
+      const k = p.checked;
+      t({
+        type: "enum",
+        value: k
+      });
+    })(b),
+    children: [l("div", {
+      class: "flex items-center gap-1",
+      children: [l("ul", {
+        style: {
+          maxHeight: 6.5 * Zt + 5 * Qt + 2 * Xt
+        },
+        class: Yt({
+          variant: e.config.options.length === 1 ? "singleOption" : void 0
+        }),
+        children: e.config.options.map((b, p) => {
+          const k = `checked.${b.value}`, {
+            ref: v,
+            ...E
+          } = a(k);
+          return l("li", {
+            class: "relative",
+            children: l(hs, {
+              option: b,
+              autoFocus: p === 0,
+              ref: (S) => {
+                S && p === 0 && (c.current = S), v(S);
+              },
+              id: k,
+              ...E,
+              onClick: n ? () => t({
+                type: "enum",
+                value: [b.value]
+              }) : void 0
+            })
+          }, b.value);
+        })
+      }), l("div", {
+        class: "flex flex-col items-center gap-2 pr-2.5 pt-2.5",
+        children: [n ? null : l(be, {}), e.config.minSelected === 0 && l(ve, {
+          type: "button",
+          onClick: () => t({
+            type: "enum",
+            value: []
+          })
+        })]
+      })]
+    }), l("div", {
+      class: "px-1",
+      children: l(Ce, {
+        error: (x = u.checked) == null ? void 0 : x.root
+      })
+    })]
+  });
+}, ms = Se("number"), gs = (e, t) => {
+  const r = e.min ?? Number.MIN_SAFE_INTEGER, n = e.max ?? Number.MAX_SAFE_INTEGER, s = e.decimalCases ?? 0;
+  return Ye(he({
+    number: jr(t("validation_number"), [zr(r, t("validation_number_min", {
+      min: r
+    })), qr(n, t("validation_number_max", {
+      max: n
+    })), Ur((a) => a === Number(a.toFixed(s)), t("validation_number_decimal_cases", {
+      count: s
+    }))])
+  }));
+}, ys = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  var b;
+  const r = e.config.defaultValue, n = e.key ? (b = M.current$.value.flow) == null ? void 0 : b.data.submissions[e.key] : void 0, {
+    t: s
+  } = Z(), {
+    register: a,
+    handleSubmit: i,
+    formState: {
+      errors: u
+    }
+  } = Xe({
+    defaultValues: {
+      number: r ? Number(r) : ms(n) ? n.value : void 0
+    },
+    resolver: gs(e.config, s)
+  }), {
+    ref: c,
+    ...h
+  } = a("number", {
+    required: !e.config.optional,
+    valueAsNumber: !0
+  }), x = re();
+  return pe(() => {
+    x.current && (x.current.focus(), x.current.select());
+  }, []), l("form", {
+    class: "flex flex-col gap-1 p-2.5",
+    onSubmit: i((p) => {
+      p.number !== void 0 && t({
+        type: "number",
+        value: p.number
+      });
+    }),
+    children: [l("div", {
+      class: "flex items-center gap-2",
+      children: [l("div", {
+        class: "relative min-w-0 flex-grow",
+        children: [l("input", {
+          ...h,
+          id: "chat-input",
+          autocomplete: "off",
+          autoCapitalize: "off",
+          autoCorrect: "off",
+          autoFocus: !0,
+          ref: (p) => {
+            p && (x.current = p), c(p);
+          },
+          type: "text",
+          min: e.config.min,
+          max: e.config.max,
+          class: Te({
+            optional: e.config.optional,
+            className: "[type=number:-webkit-inner-spin-button] w-full rounded-full [-webkit-outer-spin-button:none]"
+          }),
+          placeholder: e.config.placeholder
+        }), e.config.optional && l(ve, {
+          class: "absolute right-0 top-0",
+          onClick: () => t(null)
+        })]
+      }), l(be, {})]
+    }), l(Ce, {
+      error: u.number
+    })]
+  });
+}, bs = (e) => {
+  if (e === "")
+    return {
+      countryCode: "",
+      phoneNumber: ""
+    };
+  const t = Object.entries(gt).find((s) => e.startsWith(s[1])), r = t ? t[1] : "", n = e.replace(r, "");
+  return /^\d+$/.test(n) ? {
+    countryCode: r,
+    phoneNumber: n
+  } : {
+    countryCode: "",
+    phoneNumber: ""
+  };
+}, vs = "44", xs = Se("string"), ws = Se("phone"), ks = (e) => {
+  const t = ee(e("validation_country_code"), [Lt(/^\+?[0-9 -]+$/, e("validation_country_code"))]);
+  return Ye(he({
+    countryCode: t,
+    phoneNumber: ir(ee(e("validation_phone"), [Lt(/^\+?[0-9 -]+$/, e("validation_phone"))]), (r) => r.replace(/[^0-9]/g, ""), [])
+  }));
+}, _s = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  var E;
+  const r = e.key ? (E = M.current$.value.flow) == null ? void 0 : E.data.submissions[e.key] : void 0, {
+    t: n
+  } = Z(), [s, a] = Y(), i = xs(r) ? bs(r.value) : ws(r) ? r.value : void 0, {
+    register: u,
+    handleSubmit: c,
+    formState: {
+      errors: h
+    },
+    watch: x
+  } = Xe({
+    defaultValues: {
+      countryCode: (i == null ? void 0 : i.countryCode) ?? e.config.defaultValue.countryCode ?? vs,
+      phoneNumber: (i == null ? void 0 : i.phoneNumber) ?? e.config.defaultValue.phoneNumber ?? ""
+    },
+    resolver: ks(n)
+  }), {
+    ref: b,
+    ...p
+  } = u("phoneNumber", {
+    required: !e.config.optional
+  }), k = re(), v = x("countryCode");
+  return pe(() => {
+    k.current && (k.current.focus(), k.current.select());
+  }, []), l("form", {
+    noValidate: !0,
+    class: "flex flex-col gap-1 p-2.5",
+    onSubmit: c((S) => {
+      const A = S.phoneNumber.replace(/[^0-9]/g, ""), g = S.countryCode.replace(/[^0-9]/g, "");
+      if (a(void 0), A.length + g.length > (e.config.maxChars || Number.POSITIVE_INFINITY))
+        return a(n("validation_max_chars", {
+          count: e.config.maxChars ?? 999
+        }));
+      if (A.length + g.length < (e.config.minChars || 0))
+        return a(n("validation_min_chars", {
+          count: e.config.minChars ?? 1
+        }));
+      e.config.submissionFormat === "phone" ? t({
+        type: "phone",
+        value: {
+          countryCode: g,
+          phoneNumber: A
+        }
+      }) : t({
+        type: "string",
+        value: v + S.phoneNumber
+      });
+    }),
+    children: [l("div", {
+      class: "flex items-center gap-2",
+      children: [l("div", {
+        class: "relative flex min-w-0 flex-1 flex-grow gap-2",
+        children: [l("label", {
+          class: "text-neutral-12 bg-lowest hover:bg-neutral-5 placeholder:text-neutral-8 focus-visible:outline-accent-7 focus-within:bg-neutral-5 focus-within:outline-accent-7 outline-divider relative flex h-full cursor-pointer appearance-none items-center justify-center overflow-hidden text-ellipsis whitespace-nowrap rounded-l-full border-solid px-3 py-1.5 text-center text-base outline outline-2 transition-all focus-within:outline-none",
+          htmlFor: `isdk_phone_${e.key}`,
+          children: [l("span", {
+            children: ["+", v]
+          }), l("select", {
+            ...u("countryCode", {}),
+            id: `isdk_phone_${e.key}`,
+            class: "absolute inset-0 opacity-0",
+            children: Object.entries(gt).map(([S, A]) => l("option", {
+              value: A,
+              children: [S, " (+", A, ")"]
+            }, S))
+          })]
+        }), l("input", {
+          ...p,
+          id: "chat-input",
+          type: "tel",
+          inputMode: "tel",
+          autocomplete: "off",
+          autoCapitalize: "off",
+          autoCorrect: "off",
+          autoFocus: !0,
+          ref: (S) => {
+            S && (k.current = S), b(S);
+          },
+          class: Te({
+            optional: e.config.optional,
+            className: "flex-1 rounded-r-full"
+          }),
+          placeholder: e.config.placeholder
+        }), e.config.optional && l(ve, {
+          class: "absolute right-0 top-0",
+          onClick: () => t(null)
+        })]
+      }), l(be, {})]
+    }), l(Ce, {
+      error: h.countryCode || h.phoneNumber || {
+        message: s
+      }
+    })]
+  });
+}, Ss = ({
+  input: e,
+  onSubmitSuccess: t
+}) => l("div", {
+  class: "flex flex-col items-center py-3",
+  children: l("button", {
+    class: "bg-accent-9 hover:bg-accent-10 active:bg-submit-bg-active hover:border-accent-10 active:border-submit-bg-active border-accent-9 ring-accent-6 focus-visible:outline-accent-8 ring-offset-neutral-1 flex cursor-pointer rounded-full border border-solid px-5 py-3 pr-4 text-white outline-none ring-1 ring-offset-[1.5px] transition-all duration-300 focus-visible:outline-2 active:ring-2 active:ring-offset-2",
+    name: e.key,
+    onClick: () => {
+      t(null);
+    },
+    children: l("span", {
+      class: "flex items-center gap-1.5",
+      children: [l("span", {
+        class: "inline-flex items-center text-sm font-medium",
+        children: e.config.label || "Submit"
+      }), l("svg", {
+        stroke: "currentColor",
+        "stroke-width": "1.5",
+        width: "16",
+        height: "16",
+        viewBox: "0 0 16 16",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+        children: [l("path", {
+          d: "M4 8L8 4L12 8"
+        }), l("path", {
+          d: "M8 4V13"
+        })]
+      })]
+    })
+  })
+}), dt = {
+  empty: "Please enter some text",
+  email: "That doesn’t look like a valid email address",
+  phone: "That doesn’t look like a valid phone number",
+  url: "That doesn’t look like a valid URL"
+}, Cs = {
+  email: {
+    type: "email",
+    inputMode: "email",
+    formNoValidate: !0
+  },
+  text: {
+    type: "text",
+    inputMode: "text"
+  },
+  url: {
+    type: "url",
+    inputMode: "url",
+    formNoValidate: !0
+  }
+}, As = Se("string"), Es = (e, t) => {
+  const r = {
+    maxLength: t("validation_max_chars", {
+      count: e.maxChars ?? 999
+    }),
+    minLength: t("validation_min_chars", {
+      count: e.minChars ?? 1
+    })
+  };
+  return Ye(he({
+    text: {
+      email: ee(dt.email, [Kr(dt.email), je(e.minChars ?? 1, r.minLength), $e(e.maxChars ?? 1 / 0, r.maxLength)]),
+      text: ee([je(e.minChars ?? 1, r.minLength), $e(e.maxChars ?? 1 / 0, r.maxLength)]),
+      url: ee([Gr(dt.url), je(e.minChars ?? 1, r.minLength), $e(e.maxChars ?? 1 / 0, r.maxLength)])
+    }[e.format]
+  }));
+}, Is = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  var b;
+  const {
+    t: r
+  } = Z(), n = e.key ? (b = M.current$.value.flow) == null ? void 0 : b.data.submissions[e.key] : void 0, s = e.config.defaultValue, {
+    register: a,
+    handleSubmit: i,
+    formState: {
+      errors: u
+    }
+  } = Xe({
+    defaultValues: {
+      text: s || (As(n) ? n.value : "")
+    },
+    resolver: Es(e.config, r)
+  }), {
+    ref: c,
+    ...h
+  } = a("text", {
+    required: !e.config.optional
+  }), x = re();
+  return pe(() => {
+    x.current && (x.current.focus(), x.current.select());
+  }, []), l("form", {
+    noValidate: !0,
+    class: "flex flex-col gap-1 p-2.5",
+    onSubmit: i((p) => {
+      t({
+        type: "string",
+        value: p.text
+      });
+    }),
+    children: [l("div", {
+      class: "flex items-center gap-2",
+      children: [l("div", {
+        class: "relative min-w-0 flex-1",
+        children: [l("input", {
+          id: "chat-input",
+          ...h,
+          ...Cs[e.config.format],
+          autocomplete: "off",
+          autoCapitalize: "off",
+          autoCorrect: "off",
+          autoFocus: !0,
+          ref: (p) => {
+            p && (x.current = p), c(p);
+          },
+          placeholder: e.config.placeholder,
+          class: Te({
+            optional: !!e.config.optional,
+            className: "w-full rounded-full"
+          })
+        }), e.config.optional && l(ve, {
+          class: "absolute right-0 top-0",
+          onClick: () => t(null)
+        })]
+      }), l(be, {})]
+    }), l(Ce, {
+      error: u.text
+    })]
+  });
+}, Vs = {
+  text: Is,
+  phone: _s,
+  "multiple-choice": ps,
+  boolean: Tn,
+  file: jn,
+  submit: Ss,
+  address: Vn,
+  number: ys
+}, Ms = ({
+  logger: e
+}) => {
+  var a;
+  const t = (a = M.current$.value.flow) == null ? void 0 : a.data.currentInput, [r, n] = yn(), s = re(null);
+  return M.inputHeight$.value = n.height, ue(() => {
+    const i = s.current;
+    if (i)
+      return i.addEventListener("transitionstart", z.scrollToEnd.smooth), i.addEventListener("transitioncancel", z.scrollToEnd.smooth), i.addEventListener("transitionend", z.scrollToEnd.smooth), () => {
+        i.removeEventListener("transitionstart", z.scrollToEnd.smooth), i.removeEventListener("transitioncancel", z.scrollToEnd.smooth), i.removeEventListener("transitionend", z.scrollToEnd.smooth);
+      };
+  }, []), l("div", {
+    ref: s,
+    class: "ease-expo-out absolute bottom-0 w-full overflow-hidden rounded-b-3xl backdrop-blur-xl transition-all duration-700 will-change-[height]",
+    style: {
+      height: n.height
+    },
+    children: l("div", {
+      ref: r,
+      class: "border-divider flex flex-col justify-end border-t",
+      children: t ? (() => {
+        const i = Vs[t.type];
+        return l(i, {
+          logger: e,
+          onSubmitSuccess: z.onSubmitSuccessFn$.value,
+          input: t
+        });
+      })() : l("div", {
+        class: "flex items-center gap-2 p-2.5",
+        children: [l("input", {
+          "aria-hidden": "true",
+          id: "chat-input",
+          class: Te({
+            optional: !1,
+            className: "flex-grow rounded-full"
+          }),
+          disabled: !0
+        }), l(be, {
+          disabled: !0,
+          "aria-hidden": "true",
+          tabIndex: -1
+        })]
+      })
+    })
+  });
+};
+var Fs = function(e) {
+  return e instanceof RegExp;
+}, Ls = function(t) {
+  var r = /[\\^$.*+?()[\]{}|]/g, n = RegExp(r.source);
+  return t && n.test(t) ? t.replace(r, "\\$&") : t;
+}, _r = function(e) {
+  return typeof e == "string";
+}, Ns = function(e) {
+  var t = [];
+  return e.forEach(function(r) {
+    Array.isArray(r) ? t = t.concat(r) : t.push(r);
+  }), t;
+};
+function Ts(e, t, r) {
+  var n = 0, s = 0;
+  if (e === "")
+    return e;
+  if (!e || !_r(e))
+    throw new TypeError("First argument to react-string-replace#replaceString must be a string");
+  var a = t;
+  Fs(a) || (a = new RegExp("(" + Ls(a) + ")", "gi"));
+  for (var i = e.split(a), u = 1, c = i.length; u < c; u += 2) {
+    if (i[u] === void 0 || i[u - 1] === void 0) {
+      console.warn("reactStringReplace: Encountered undefined value during string replacement. Your RegExp may not be working the way you expect.");
+      continue;
+    }
+    s = i[u].length, n += i[u - 1].length, i[u] = r(i[u], u, n), n += s;
+  }
+  return i;
+}
+var Ds = function(t, r, n) {
+  return Array.isArray(t) || (t = [t]), Ns(t.map(function(s) {
+    return _r(s) ? Ts(s, r, n) : s;
+  }));
+};
+const Pe = /* @__PURE__ */ nr(Ds), Rs = /(\[[^\]]+\]\([^)]+\))/g, Os = /\[([^\]]+)\]\(([^)]+)\)/, Bs = /(https?:\/\/[^\s]+)/g, Ps = /_(.*?)_/g, $s = /\*\*(.*?)\*\*/g, er = "text-accent-10 hover:text-accent-11 no-underline underline-offset-2 hover:underline", js = (e) => {
+  const t = Pe(e, Rs, (a, i) => {
+    const [, u, c] = a.match(Os) ?? [];
+    return c ? l("a", {
+      class: er,
+      href: c,
+      children: u ?? c
+    }, c + i) : l("span", {
+      children: "INVALID LINK"
+    });
+  }), r = Pe(t, Bs, (a, i) => l("a", {
+    class: er,
+    href: a,
+    children: a
+  }, a + i)), n = Pe(r, Ps, (a, i) => l("em", {
+    children: a
+  }, a + i));
+  return Pe(n, $s, (a, i) => l("strong", {
+    children: a
+  }, a + i));
+}, zs = Ze("select-text max-w-[min(100%,24rem)] [text-wrap:pretty] leading-snug flex-shrink min-w-[2rem] py-2 px-3 rounded-[18px] min-h-[36px] break-words relative", {
+  variants: {
+    side: {
+      left: "bg-bubble-weak-bg text-neutral-12 shadow-surface-sm outline outline-1 outline-bubble-weak rounded-bl-md",
+      right: "ml-auto bg-accent-9 text-white rounded-br-md shadow-surface-sm shadow-bubble-strong-shadow"
+    },
+    animate: {
+      true: "animate-bubble-in",
+      false: ""
+    }
+  },
+  defaultVariants: {
+    side: "left"
+  }
+}), qs = ({
+  children: e,
+  className: t,
+  animate: r,
+  side: n,
+  ...s
+}) => l("p", {
+  style: {
+    transformOrigin: n === "left" ? "0% 50%" : "100% 50%"
+  },
+  class: zs({
+    className: t,
+    side: n,
+    animate: r
+  }),
+  ...s,
+  children: e
+}), Us = ({
+  message: e
+}) => l("div", {
+  class: "bg-accent-3 flex w-full items-center justify-center overflow-hidden rounded-xl px-2 py-2",
+  children: l("a", {
+    onClick: e.onClick,
+    class: "bg-lowest shadow-surface-sm ring-accent-6 hover:ring-accent-8 active:bg-accent-2 active:text-accent-10 text-accent-9 focus-visible:ring-accent-7/50 text-wrap-balance flex items-center gap-1.5 rounded-full py-2 pl-4 pr-2.5 text-center no-underline ring-1 transition-all focus:outline-none focus-visible:ring-4 focus-visible:ring-offset-2",
+    target: "_blank",
+    href: e.href,
+    children: [e.text, l("svg", {
+      class: "flex-none",
+      width: "15",
+      height: "15",
+      viewBox: "0 0 15 15",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: l("path", {
+        d: "M3.64645 11.3536C3.45118 11.1583 3.45118 10.8417 3.64645 10.6465L10.2929 4L6 4C5.72386 4 5.5 3.77614 5.5 3.5C5.5 3.22386 5.72386 3 6 3L11.5 3C11.6326 3 11.7598 3.05268 11.8536 3.14645C11.9473 3.24022 12 3.36739 12 3.5L12 9.00001C12 9.27615 11.7761 9.50001 11.5 9.50001C11.2239 9.50001 11 9.27615 11 9.00001V4.70711L4.35355 11.3536C4.15829 11.5488 3.84171 11.5488 3.64645 11.3536Z",
+        fill: "currentColor",
+        "fill-rule": "evenodd",
+        "clip-rule": "evenodd"
+      })
+    })]
+  })
+}), Ks = ({
+  className: e,
+  ...t
+}) => (ue(() => {
+  z.scrollToEnd.smooth();
+}), l("div", {
+  "aria-hidden": !0,
+  children: z.isBotTyping$.value === !0 ? l("div", {
+    "aria-label": "Typing…",
+    class: Ne("flex gap-1 p-4", e),
+    ...t,
+    children: Array.from({
+      length: 3
+    }, (r, n) => l("div", {
+      class: "bg-accent-9 h-1.5 w-1.5 animate-bounce rounded-full",
+      style: {
+        animationDelay: `${-n * 200}ms`
+      }
+    }))
+  }) : void 0
+})), Gs = {
+  bot: "left",
+  user: "right"
+}, Hs = Ze("w-full select-none py-2 text-wrap-balance text-center text-[10px] uppercase tracking-widest drop-shadow-[0_1.5px_var(--i-color-n-1)]", {
+  variants: {
+    variant: {
+      info: "text-neutral-8",
+      warning: "text-[#FFC107]",
+      error: "text-error-9",
+      success: "text-[#4CAF50]"
+    }
+  }
+}), Ws = ({
+  lastSentMessageFooter: e
+}) => {
+  var r;
+  const t = ((r = M.current$.value.flow) == null ? void 0 : r.data.messages) ?? [];
+  return ue(() => {
+    z.scrollToEnd.smooth();
+  }, [t.length]), l("ol", {
+    "aria-label": "Chat messages",
+    class: "mt-auto flex flex-col justify-end gap-2 p-2 pt-[calc(var(--header-height)+1rem)]",
+    children: [t.map((n, s) => l(_e, {
+      children: l("li", {
+        class: "flex",
+        children: Ke(n).with({
+          type: "system"
+        }, (a) => l("p", {
+          class: Hs({
+            variant: a.variant
+          }),
+          children: a.text
+        })).with({
+          type: "text",
+          author: I.union("bot", "user")
+        }, (a) => {
+          const i = a.author === "user" && !t.slice(s + 1).some((h) => h.type === "text" && h.author === "user"), u = s === t.length - 1, c = a.author === "bot" ? js(a.text) : a.text;
+          return l(qs, {
+            animate: u,
+            side: Gs[a.author],
+            children: [c, i ? e : null]
+          }, s);
+        }).with({
+          type: "link"
+        }, (a) => l(Us, {
+          message: a
+        })).with({
+          type: "image"
+        }, (a) => l("img", {
+          class: "shadow-surface-md w-full max-w-[min(100%,24rem)] rounded-2xl",
+          src: a.url,
+          style: {
+            aspectRatio: a.width / a.height
+          }
+        })).with({
+          type: "file"
+        }, (a) => l(Bn, {
+          class: a.author === "bot" ? void 0 : "ml-auto",
+          file: {
+            name: a.fileName,
+            sizeKb: a.fileSizeKb
+          }
+        })).with({
+          type: "loading"
+        }, (a) => {
+          const i = t[t.length - 1];
+          return !(a === i) || z.isBotTyping$.value ? null : l("div", {
+            class: "flex flex-grow flex-col items-center justify-center",
+            children: l(Hr, {
+              class: "text-neutral-6 h-8 w-8"
+            })
+          });
+        }).exhaustive()
+      })
+    }, s)), l(Ks, {}, "typing")]
+  });
+}, na = ({
+  logger: e,
+  apiClient: t,
+  analytics: r
+}) => {
+  const {
+    flow: n
+  } = M.current$.value;
+  le(n, "Flow is required to exist to show chatbot body");
+  const s = M.viewState$.value, {
+    chatRef: a,
+    chatService: i
+  } = _n(), {
+    t: u
+  } = Z(), [c, h] = Y();
+  return pe(() => {
+    s === "maximised" && z.scrollToEnd.instant();
+  }, [s]), pe(() => {
+    var S, A;
+    const {
+      state: x,
+      flow: b
+    } = M.current$.peek();
+    if (x !== "loaded")
+      throw new Error(u("invalid_state"));
+    let p = b.data.nodeHistory.at(-1);
+    if (z.scrollToEnd.instant(), M.setInput(void 0), b.data.isFinished)
+      return;
+    p === void 0 ? (p = rr(n.nodes).id, M.setCurrentNodeId(p), r.log({
+      event: "FLOW_START",
+      properties: {
+        flow_id: n.id,
+        flow_version: n.version,
+        flow_session_id: b.data.flowSessionId,
+        flow_build: n.build,
+        job: n.job
+      },
+      customProperties: (S = n.analytics) == null ? void 0 : S.customProperties
+    })) : M.removeMessagesSentByNodeIds([p]);
+    const {
+      interpret: k,
+      abort: v,
+      undo: E
+    } = Zr({
+      context: n.context,
+      analytics: {
+        service: r,
+        customProperties: (A = n.analytics) == null ? void 0 : A.customProperties
+      },
+      apiClient: t,
+      logger: e,
+      flow: n,
+      chatService: i,
+      t: u,
+      // We need to get fresh submissions, that’s why we call `peek` here.
+      getSubmissions: () => {
+        var g;
+        return (g = M.current$.peek().flow) == null ? void 0 : g.data.submissions;
+      },
+      onInterpret: (g, T) => {
+        var D;
+        const P = M.current$.peek().flow;
+        le(P), T && (P.data.sequence = P.data.sequence + 1, r.log({
+          event: "FLOW_NODE",
+          properties: {
+            flow_id: n.id,
+            flow_version: n.version,
+            from_node_id: T.id,
+            flow_build: n.build,
+            to_node_id: g.id,
+            sequence: P.data.sequence,
+            flow_session_id: P.data.flowSessionId,
+            job: n.job
+          },
+          customProperties: (D = n.analytics) == null ? void 0 : D.customProperties
+        })), M.setCurrentNodeId(g.id);
+      },
+      onFlowEnd: async () => {
+        var T;
+        M.markAsFinished();
+        const g = M.current$.peek().flow;
+        le(g), r.log({
+          event: "FLOW_END",
+          properties: {
+            flow_id: n.id,
+            flow_version: n.version,
+            flow_session_id: g.data.flowSessionId,
+            flow_build: n.build,
+            job: n.job
+          },
+          customProperties: (T = n.analytics) == null ? void 0 : T.customProperties
+        });
+      }
+    });
+    return h(() => E), k(p), v;
+  }, [r, t, i, e, n, u]), l(_e, {
+    children: [l("div", {
+      ref: a,
+      className: "hide-scrollbars relative flex w-full max-w-full flex-grow flex-col overflow-y-scroll",
+      style: {
+        WebkitOverflowScrolling: "touch",
+        paddingBottom: M.inputHeight$.value
+      },
+      children: l(Ws, {
+        lastSentMessageFooter: n.data.isFinished || !c ? null : l(Zs, {
+          undoFn: c
+        })
+      })
+    }), l(Ms, {
+      logger: e
+    })]
+  });
+}, Js = (e) => "key" in e.data && e.data.key ? [e.data.key] : "keys" in e.data ? Object.values(e.data.keys).filter((t) => typeof t == "string") : [], Zs = ({
+  undoFn: e
+}) => {
+  const {
+    t
+  } = Z();
+  return l("div", {
+    class: "absolute bottom-0 right-0 flex w-full translate-y-full justify-end",
+    children: l("button", {
+      class: "fr touch-hitbox text-neutral-9 hover:text-neutral-12 rounded-full p-1 text-right text-xs transition-all",
+      onClick: async () => {
+        const {
+          flow: r
+        } = M.current$.peek();
+        le(r);
+        const {
+          removed: n
+        } = e(r.data.nodeHistory), s = r.data.nodeHistory.splice(-n);
+        s.length !== 0 && (M.removeMessagesSentByNodeIds(s), M.setInput(void 0), s.pop(), s.map((a) => r.nodes.find((i) => i.id === a)).filter(Boolean).flatMap(Js).forEach((a) => delete r.data.submissions[a]), M.current$.value = {
+          ...M.current$.value
+        });
+      },
+      children: t("undo")
+    })
+  });
+};
+export {
+  na as ChatbotBody
+};