@inploi/plugin-chatbot 7.0.2 → 7.1.0

package/dist/chatbot-body-b4327f15.js

@@ -0,0 +1,4076 @@
+import { g as Ke, i as rr, k as Oe, a as nr, b as me, A as De, c as Tr, M as Ge, z as R, h as se, _ as ae, p as ue, F as ft, u as Y, o as c, d as je, e as lt, y as ye, s as A, f as Xe, j as we, l as Dr, m as ge, n as Rr, q as it, r as Q, t as Or, v as sr, w as Br, x as Pr, B as $r, C as Fe, D as G, E as jr, G as Ur, H as pe, I as Be, J as He, K as ar, L as zr, N as qr, O as Hr, P as Kr, Q as Gr, R as Wr, S as ir, T as Jr, U as Xr, V as Zr, W as Yr, X as Qr } from "./index-05d5a78d.js";
+import "@inploi/sdk";
+const Mt = ({
+  condition: e,
+  context: t,
+  submissions: r,
+  ifBlock: n
+}) => {
+  const [a, ...s] = e.compareKey.split(".");
+  if (!a)
+    return !1;
+  const o = lr({
+    context: t,
+    key: a,
+    path: s,
+    submissions: r
+  });
+  if (!o)
+    return !1;
+  switch (o.type) {
+    case "address": {
+      const i = Ke(o.value, s.join("."));
+      switch (e.compare) {
+        case "equals":
+          return i === e.compareValue;
+        case "contains":
+          return i ? i.includes(e.compareValue) : !1;
+        case "notEquals":
+          return i !== e.compareValue;
+        case "notContains":
+          return i ? !i.includes(e.compareValue) : !0;
+      }
+      break;
+    }
+    case "integration": {
+      if (typeof o.value != "object" || Array.isArray(o.value))
+        return !1;
+      const i = Ke(o.value, s.join(".")), f = {
+        ...n,
+        data: {
+          ...n.data,
+          compareKey: "_temp"
+        }
+      };
+      switch (typeof i) {
+        case "boolean":
+          return Re(f, {
+            submissions: {
+              _temp: {
+                value: i,
+                type: "boolean"
+              }
+            },
+            context: t
+          });
+        case "string":
+          return Re(f, {
+            submissions: {
+              _temp: {
+                value: i,
+                type: "string"
+              }
+            },
+            context: t
+          });
+        case "number":
+          return Re(f, {
+            submissions: {
+              _temp: {
+                value: i,
+                type: "number"
+              }
+            },
+            context: t
+          });
+        case "object":
+          return Array.isArray(i) && i.every(rr) ? Re(f, {
+            submissions: {
+              _temp: {
+                value: i,
+                type: "enum"
+              }
+            },
+            context: t
+          }) : !1;
+      }
+      break;
+    }
+    case "boolean": {
+      const i = e.compareValue === "true";
+      switch (e.compare) {
+        case "equals":
+          return o.value === i;
+        case "notEquals":
+          return o.value !== i;
+      }
+      break;
+    }
+    case "phone":
+    case "string": {
+      const i = o.type === "phone" ? Ze(o.value) : o.value;
+      switch (e.compare) {
+        case "equals":
+          return i === e.compareValue;
+        case "contains":
+          return i ? i.includes(e.compareValue) : !1;
+        case "notEquals":
+          return i !== e.compareValue;
+        case "notContains":
+          return i ? !i.includes(e.compareValue) : !0;
+      }
+      break;
+    }
+    case "number": {
+      try {
+        const i = Number(e.compareValue);
+        switch (e.compare) {
+          case "equals":
+            return o.value === i;
+          case "notEquals":
+            return o.value !== i;
+          case "greaterThan":
+            return o.value > i;
+          case "greaterThanOrEqualTo":
+            return o.value >= i;
+          case "lessThan":
+            return o.value < i;
+          case "lessThanOrEqualTo":
+            return o.value <= i;
+        }
+      } catch {
+        return console.error(`Failed to parse number in if-block ${n.id}`, o.value), !1;
+      }
+      break;
+    }
+    case "enum":
+      switch (e.compare) {
+        case "equals":
+          return o.value.length === 1 && o.value[0] === e.compareValue;
+        case "notEquals":
+          return o.value.length === 1 && o.value[0] !== e.compareValue;
+        case "contains":
+          return o.value.includes(e.compareValue);
+        case "notContains":
+          return !o.value.includes(e.compareValue);
+      }
+      break;
+  }
+}, Re = (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 s of n)
+      if (Mt({
+        condition: s,
+        context: t,
+        submissions: r,
+        ifBlock: e
+      }))
+        return !0;
+    return !1;
+  } else {
+    for (const s of n)
+      if (!Mt({
+        condition: s,
+        context: t,
+        submissions: r,
+        ifBlock: e
+      }))
+        return !1;
+    return !0;
+  }
+}, en = /{{\s*([^}]+?)\s*(?:\|\s*([^}]+?)\s*)?}}/g, ie = (e, {
+  context: t,
+  submissions: r
+}) => e.replace(en, (n, a, s = "") => {
+  const [o, ...i] = a.trim().split("."), f = lr({
+    key: o,
+    path: i,
+    submissions: r,
+    context: t
+  });
+  if (!f)
+    return s;
+  switch (f.type) {
+    case "boolean":
+      return f.value === !0 ? "true" : "false";
+    case "file":
+      return f.value.map((p) => `${p.name} (${Oe(p.sizeKb)})`).join(", ");
+    case "enum":
+      return f.value.join(", ");
+    case "address":
+      return Object.values(f.value).filter((p) => p && p.trim().length > 0).join(", ");
+    case "number":
+    case "string":
+      return f.value ? f.value.toString() : s;
+    case "phone":
+      return Ze(f.value);
+    case "integration": {
+      if (typeof f.value != "object" || Array.isArray(f.value))
+        break;
+      const p = Ke(f.value, i.join("."));
+      switch (typeof p) {
+        case "boolean":
+          return p === !0 ? "true" : "false";
+        case "string":
+          return p;
+        case "number":
+          return p.toString();
+        case "object":
+          if (Array.isArray(p) && p.every(rr))
+            return p.join(", ");
+      }
+      break;
+    }
+  }
+  return s;
+}), or = ({
+  node: e,
+  nodes: t,
+  stopWhen: r
+}) => {
+  if ((r == null ? void 0 : r(e)) === !0)
+    return e;
+  const n = e.nextId ? t.find((a) => a.id === e.nextId) : void 0;
+  if (n)
+    return or({
+      node: n,
+      nodes: t,
+      stopWhen: r
+    });
+}, tn = ({
+  childNode: e,
+  nodes: t
+}) => {
+  const n = t.filter((a) => a.type === "if-block").find((a) => {
+    if (!a.branchId)
+      return !1;
+    const s = t.find((i) => i.id === a.branchId);
+    if (!s)
+      return !1;
+    const o = or({
+      node: s,
+      nodes: t,
+      stopWhen: (i) => i.id === e.id
+    });
+    return !(!o || o.id !== e.id);
+  });
+  if (n != null && n.nextId)
+    return t.find((a) => a.id === n.nextId);
+}, rn = ({
+  flow: e,
+  analytics: t,
+  logger: r,
+  platformClient: n,
+  context: a,
+  apiClient: s,
+  getSubmissions: o,
+  chatService: i,
+  onFlowEnd: f,
+  onInterpret: p,
+  t: C
+}) => {
+  let v = new AbortController();
+  const h = {
+    ...t.service,
+    log: (b) => t.service.log({
+      ...b,
+      customProperties: {
+        ...b.customProperties,
+        ...t.customProperties
+      }
+    })
+  }, y = async (b, V) => {
+    const E = o();
+    p == null || p(b, V);
+    try {
+      await nn({
+        flow: e,
+        analytics: h,
+        logger: r,
+        platformClient: n,
+        apiClient: s,
+        context: a,
+        node: b,
+        submissions: E,
+        t: C,
+        chat: {
+          sendMessage: async (x) => i.send({
+            groupId: b.id,
+            message: x,
+            signal: v.signal
+          }),
+          userInput: async (x) => i.input({
+            input: x,
+            signal: v.signal
+          }),
+          addToSubmissions: i.addToSubmissions
+        },
+        next: (x) => {
+          const _ = x ? e.nodes.find((I) => I.id === x) : tn({
+            childNode: b,
+            nodes: e.nodes
+          });
+          return _ ? y(_, b) : f == null ? void 0 : f(b);
+        },
+        end: () => f == null ? void 0 : f(b)
+      });
+    } catch (x) {
+      if (x instanceof De)
+        return;
+      throw x;
+    }
+  };
+  return {
+    interpret: async (b) => {
+      const V = e.nodes.find((E) => E.id === b) ?? nr(e.nodes);
+      return y(V);
+    },
+    undo: (b) => {
+      let V = 1;
+      const E = e.nodes.find((_) => _.id === b[b.length - 1]);
+      for (let _ = b.length - 2; _ > 0; _--) {
+        const I = b[_], O = e.nodes.find((M) => M.id === I);
+        if (!O || (V++, O.type.startsWith("question-")))
+          break;
+      }
+      v.abort(), v = new AbortController();
+      const x = e.nodes.find((_) => _.id === b[b.length - V]);
+      return me(x, "Undo failed: new start node not found"), y(x, E), {
+        removed: V
+      };
+    },
+    abort: () => {
+      v.abort();
+    }
+  };
+}, Ze = (e) => `+${e.countryCode} ${e.phoneNumber}`;
+async function nn(e) {
+  const t = e.node;
+  switch (t.type) {
+    case "text":
+      return hn({
+        ...e,
+        node: t
+      });
+    case "image":
+      return pn({
+        ...e,
+        node: t
+      });
+    case "question-text":
+      return mn({
+        ...e,
+        node: t
+      });
+    case "question-enum":
+      return bn({
+        ...e,
+        node: t
+      });
+    case "question-number":
+      return gn({
+        ...e,
+        node: t
+      });
+    case "question-phone":
+      return yn({
+        ...e,
+        node: t
+      });
+    case "question-boolean":
+      return vn({
+        ...e,
+        node: t
+      });
+    case "question-file":
+      return wn({
+        ...e,
+        node: t
+      });
+    case "question-address":
+      return xn({
+        ...e,
+        node: t
+      });
+    case "end-flow":
+      return kn({
+        ...e,
+        node: t
+      });
+    case "if-block":
+      return fn({
+        ...e,
+        node: t
+      });
+    case "jump":
+      return ln({
+        ...e,
+        node: t
+      });
+    case "link":
+      return dn({
+        ...e,
+        node: t
+      });
+    case "integration-application-submit":
+      return un({
+        ...e,
+        node: t
+      });
+    case "add-submission":
+      return cn({
+        ...e,
+        node: t
+      });
+    case "integration-workflow-get":
+      throw Error("Workflow should be unreachable");
+    case "identify":
+      return an({
+        ...e,
+        node: t
+      });
+    case "check-duplicate":
+      return on({
+        ...e,
+        node: t
+      });
+    case "feedback":
+      return sn({
+        ...e,
+        node: t
+      });
+    default:
+      throw new Error(`Unknown node: ${JSON.stringify(t)}`);
+  }
+}
+const Ee = (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 sn({
+  next: e,
+  node: t
+}) {
+  e(t.nextId);
+}
+async function an({
+  next: e,
+  node: t,
+  analytics: r,
+  submissions: n,
+  logger: a
+}) {
+  if (!n)
+    return e(t.nextId);
+  try {
+    r.log({
+      event: "IDENTIFY",
+      properties: {
+        identifier: Ee(n, t.data.key).toString(),
+        first_name: t.data.firstName ? Ee(n, t.data.firstName).toString() : void 0,
+        last_name: t.data.lastName ? Ee(n, t.data.lastName).toString() : void 0,
+        email: t.data.email ? Ee(n, t.data.email).toString() : void 0,
+        phone_number: t.data.phoneNumber ? Ee(n, t.data.phoneNumber).toString() : void 0,
+        custom_traits: t.data.customTraits ? Object.fromEntries(t.data.customTraits.map(({
+          key: s,
+          value: o
+        }) => {
+          var i;
+          return [s, (i = n[o]) == null ? void 0 : i.value];
+        })) : void 0
+      }
+    });
+  } catch (s) {
+    a.error(s);
+  } finally {
+    e(t.nextId);
+  }
+}
+async function on({
+  next: e,
+  node: t,
+  platformClient: r,
+  submissions: n,
+  flow: a,
+  logger: s,
+  chat: o
+}) {
+  var f;
+  let i = {
+    isDuplicate: !1
+  };
+  if (n && r) {
+    const p = t.data.scope === "job" ? (f = a.job) == null ? void 0 : f.id : void 0;
+    if (t.data.scope === "company" || p != null)
+      try {
+        i = await r.checkDuplicate({
+          email: Ee(n, t.data.email).toString(),
+          jobId: p,
+          scope: t.data.scope
+        });
+      } catch (C) {
+        s.error("[check-duplicate]", C);
+      }
+  }
+  o.addToSubmissions(t.data.key, {
+    type: "integration",
+    value: i
+  }), e(t.nextId);
+}
+async function ln({
+  next: e,
+  node: t
+}) {
+  e(t.data.targetId);
+}
+async function cn({
+  next: e,
+  node: t,
+  logger: r,
+  submissions: n,
+  context: a
+}) {
+  if (!n) {
+    r.error("Submissions not found");
+    return;
+  }
+  n[t.data.key] = {
+    type: "string",
+    value: ie(t.data.value, {
+      submissions: n,
+      context: a
+    })
+  }, e(t.nextId);
+}
+async function un({
+  chat: e,
+  next: t,
+  node: r,
+  logger: n,
+  apiClient: a,
+  submissions: s,
+  analytics: o,
+  flow: i,
+  t: f
+}) {
+  const p = async (C) => {
+    C !== !0 && await e.userInput({
+      type: "submit",
+      key: void 0,
+      config: {
+        label: r.data.submitLabel
+      }
+    }), await e.sendMessage({
+      type: "loading"
+    });
+    const {
+      anonymous_id: v,
+      session_id: h
+    } = o.getSessionInfo(), y = await a.fetch("/flow/submit", {
+      method: "POST",
+      body: JSON.stringify({
+        log_submit: !1,
+        integration_id: r.data.integrationId,
+        anonymous_id: v,
+        session_id: h,
+        job: i.job,
+        submissions: Tr(s || {})
+      })
+    }).catch((b) => b);
+    r.data.key && e.addToSubmissions(r.data.key, {
+      type: "integration",
+      value: y
+    }), Ge(y).with({
+      integration_response: R.select(R.union({
+        service: R.optional(R.string),
+        status: R.number,
+        data: R.any
+      }, {
+        service: R.optional(R.string),
+        status: R.number,
+        error: {
+          message: R.string,
+          data: R.any
+        }
+      }))
+    }, (b) => {
+      o.log({
+        event: "FLOW_SUBMIT",
+        properties: {
+          flow_id: i.id,
+          flow_version: i.version,
+          flow_session_id: i.data.flowSessionId,
+          flow_build: i.build,
+          service: b.service ?? "INVALID_SERVICE",
+          response: {
+            status: b.status,
+            payload: "data" in b ? b.data : b.error.data ?? null
+          },
+          job: i.job
+        }
+      });
+    }).otherwise(() => {
+    }), await Ge(y).with({
+      integration_response: {
+        data: R.select("redirect", {
+          redirect_url: R.string,
+          message: R.optional(R.union(R.string, R.nullish)),
+          button_text: R.optional(R.union(R.string, R.nullish))
+        })
+      }
+    }, async (b) => {
+      await e.sendMessage({
+        type: "text",
+        author: "bot",
+        text: b.redirect.message ?? f("submission_redirect_message")
+      });
+      try {
+        const V = new URL(b.redirect.redirect_url);
+        v && !V.searchParams.has("anonymous_id") && V.searchParams.set("anonymous_id", v), await e.sendMessage({
+          type: "link",
+          href: V.toString(),
+          text: b.redirect.button_text ?? f("complete_submission"),
+          onClick: () => {
+            if (!h) {
+              n.error("session_id not set, cannot log FLOW_REDIRECT event");
+              return;
+            }
+            o.log({
+              event: "FLOW_REDIRECT",
+              properties: {
+                flow_build: i.build,
+                flow_id: i.id,
+                flow_session_id: h,
+                flow_version: i.version,
+                href: V.toString(),
+                job: i.job
+              }
+            });
+          }
+        });
+      } catch (V) {
+        n.error(`Invalid redirect URL: ${b.redirect.redirect_url}`, V), e.sendMessage({
+          type: "system",
+          variant: "error",
+          text: f("redirect_url_error")
+        });
+      }
+      t(r.nextId);
+    }).with({
+      success: !0
+    }, async () => {
+      r.data.skipConfirmation !== !0 && await e.sendMessage({
+        type: "system",
+        variant: "success",
+        text: f("submission_completed")
+      }), t(r.nextId);
+    }).with({
+      integration_response: {
+        error: R.select("error", {
+          message: R.string
+        })
+      }
+    }, async (b) => {
+      n.error(b.error), await e.sendMessage({
+        type: "system",
+        variant: "error",
+        text: b.error.message || f("submission_failed")
+      }), await p(!1);
+    }).otherwise(async (b) => {
+      n.error(b), await e.sendMessage({
+        type: "system",
+        variant: "error",
+        text: f("submission_failed")
+      }), await p(!1);
+    });
+  };
+  await p(r.data.skipConfirmation);
+}
+async function dn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: a
+}) {
+  await e.sendMessage({
+    type: "link",
+    href: ie(r.data.href, {
+      submissions: n,
+      context: a
+    }),
+    text: ie(r.data.cta, {
+      submissions: n,
+      context: a
+    })
+  }), t(r.nextId);
+}
+async function fn({
+  submissions: e,
+  next: t,
+  node: r,
+  context: n
+}) {
+  t(Re(r, {
+    submissions: e,
+    context: n
+  }) ? r.branchId : r.nextId);
+}
+async function hn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: a
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ie(r.data.text, {
+      submissions: n,
+      context: a
+    })
+  }), t(r.nextId);
+}
+async function pn({
+  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 mn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: a,
+  t: s
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ie(r.data.question, {
+      submissions: n,
+      context: a
+    })
+  });
+  const o = r.data.format === "phone" ? await e.userInput({
+    key: r.data.key,
+    type: "phone",
+    config: {
+      optional: r.data.optional,
+      placeholder: r.data.placeholder,
+      minChars: r.data.minChars,
+      maxChars: r.data.maxChars,
+      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
+    }
+  });
+  o === null ? await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: s("skipped")
+  }) : await e.sendMessage({
+    author: "user",
+    type: "text",
+    text: o.type === "phone" ? Ze(o.value) : o.value
+  }), t(r.nextId);
+}
+async function gn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: a,
+  t: s
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ie(r.data.question, {
+      submissions: n,
+      context: a
+    })
+  });
+  const o = 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
+    }
+  });
+  o === null ? await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: s("skipped")
+  }) : await e.sendMessage({
+    author: "user",
+    type: "text",
+    text: o.value.toString()
+  }), t(r.nextId);
+}
+async function yn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: a
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ie(r.data.question, {
+      submissions: n,
+      context: a
+    })
+  });
+  const s = await e.userInput({
+    key: r.data.key,
+    type: "phone",
+    config: {
+      minChars: r.data.minChars,
+      defaultValue: {
+        countryCode: r.data.defaultCountryCode
+      },
+      placeholder: r.data.placeholder,
+      submissionFormat: "phone",
+      optional: r.data.optional
+    }
+  });
+  s === null ? await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: "Skipped"
+  }) : await e.sendMessage({
+    author: "user",
+    type: "text",
+    text: s.type === "phone" ? Ze(s.value) : s.value
+  }), t(r.nextId);
+}
+async function bn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: a,
+  t: s
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ie(r.data.question, {
+      submissions: n,
+      context: a
+    })
+  });
+  const o = await e.userInput({
+    key: r.data.key,
+    type: "multiple-choice",
+    config: r.data
+  });
+  o.value.length === 0 ? await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: s("skipped")
+  }) : await e.sendMessage({
+    author: "user",
+    type: "text",
+    text: r.data.options.filter((i) => o.value.includes(i.value)).map((i) => i.label).join(", ")
+  }), t(r.nextId);
+}
+async function vn({
+  chat: e,
+  next: t,
+  node: r,
+  submissions: n,
+  context: a,
+  t: s
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ie(r.data.question, {
+      submissions: n,
+      context: a
+    })
+  });
+  const o = await e.userInput({
+    key: r.data.key,
+    type: "boolean",
+    config: {
+      optional: r.data.optional,
+      labels: {
+        true: r.data.trueLabel,
+        false: r.data.falseLabel
+      }
+    }
+  });
+  o === null ? await e.sendMessage({
+    type: "system",
+    variant: "info",
+    text: s("skipped")
+  }) : await e.sendMessage({
+    author: "user",
+    type: "text",
+    text: o.value === !0 ? r.data.trueLabel : r.data.falseLabel
+  }), t(r.nextId);
+}
+async function xn({
+  chat: e,
+  next: t,
+  node: r,
+  t: n
+}) {
+  await e.sendMessage({
+    author: "bot",
+    type: "text",
+    text: r.data.question
+  });
+  const a = await e.userInput({
+    type: "address",
+    key: r.data.key,
+    config: {
+      optional: r.data.optional,
+      keys: r.data.keys,
+      placeholder: r.data.placeholder
+    }
+  });
+  if (a === null)
+    await e.sendMessage({
+      type: "system",
+      variant: "info",
+      text: n("skipped")
+    });
+  else {
+    const s = Object.values(a.value).filter((o) => o && o.trim().length > 0).join(", ");
+    await e.sendMessage({
+      author: "user",
+      type: "text",
+      text: s
+    });
+  }
+  return t(r.nextId);
+}
+async function wn({
+  node: e,
+  chat: t,
+  next: r,
+  submissions: n,
+  context: a,
+  t: s
+}) {
+  await t.sendMessage({
+    author: "bot",
+    type: "text",
+    text: ie(e.data.question, {
+      submissions: n,
+      context: a
+    })
+  });
+  const o = 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 (o === null)
+    await t.sendMessage({
+      type: "system",
+      variant: "info",
+      text: s("skipped")
+    });
+  else
+    for (const i of o.value)
+      await t.sendMessage({
+        author: "user",
+        type: "file",
+        fileName: i.name,
+        fileSizeKb: i.sizeKb
+      });
+  r(e.nextId);
+}
+async function kn({
+  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 a = Ke(n, t.join("."));
+    switch (typeof a) {
+      case "string":
+        return {
+          type: "string",
+          value: a
+        };
+      case "number":
+        return {
+          type: "number",
+          value: a
+        };
+      case "boolean":
+        return {
+          type: "boolean",
+          value: a
+        };
+      default:
+        console.warn(`Unexpected type for $context.${t.join(".")}`, a);
+        return;
+    }
+  }
+  return r == null ? void 0 : r[e];
+};
+function Lt(e, t) {
+  let r;
+  return (...n) => {
+    window.clearTimeout(r), r = window.setTimeout(() => e(...n), t);
+  };
+}
+function _n({ debounce: e, scroll: t, polyfill: r, offsetSize: n } = { debounce: 0, scroll: !1, offsetSize: !1 }) {
+  const a = r || (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 [s, o] = se({ left: 0, top: 0, width: 0, height: 0, bottom: 0, right: 0, x: 0, y: 0 }), i = ae({ element: null, scrollContainers: null, resizeObserver: null, lastBounds: s, orientationHandler: null }), f = e ? typeof e == "number" ? e : e.scroll : null, p = e ? typeof e == "number" ? e : e.resize : null, C = ae(!1);
+  ue(() => (C.current = !0, () => void (C.current = !1)));
+  const [v, h, y] = ft(() => {
+    const x = () => {
+      if (!i.current.element)
+        return;
+      const { left: _, top: I, width: O, height: M, bottom: be, right: Ce, x: oe, y: de } = i.current.element.getBoundingClientRect(), z = { left: _, top: I, width: O, height: M, bottom: be, right: Ce, x: oe, y: de };
+      i.current.element instanceof HTMLElement && n && (z.height = i.current.element.offsetHeight, z.width = i.current.element.offsetWidth), Object.freeze(z), C.current && !Vn(i.current.lastBounds, z) && o(i.current.lastBounds = z);
+    };
+    return [x, p ? Lt(x, p) : x, f ? Lt(x, f) : x];
+  }, [o, n, f, p]);
+  function b() {
+    i.current.scrollContainers && (i.current.scrollContainers.forEach((x) => x.removeEventListener("scroll", y, !0)), i.current.scrollContainers = null), i.current.resizeObserver && (i.current.resizeObserver.disconnect(), i.current.resizeObserver = null), i.current.orientationHandler && ("orientation" in screen && "removeEventListener" in screen.orientation ? screen.orientation.removeEventListener("change", i.current.orientationHandler) : "onorientationchange" in window && window.removeEventListener("orientationchange", i.current.orientationHandler));
+  }
+  function V() {
+    i.current.element && (i.current.resizeObserver = new a(y), i.current.resizeObserver.observe(i.current.element), t && i.current.scrollContainers && i.current.scrollContainers.forEach((x) => x.addEventListener("scroll", y, { capture: !0, passive: !0 })), i.current.orientationHandler = () => {
+      y();
+    }, "orientation" in screen && "addEventListener" in screen.orientation ? screen.orientation.addEventListener("change", i.current.orientationHandler) : "onorientationchange" in window && window.addEventListener("orientationchange", i.current.orientationHandler));
+  }
+  const E = (x) => {
+    !x || x === i.current.element || (b(), i.current.element = x, i.current.scrollContainers = cr(x), V());
+  };
+  return Sn(y, !!t), Cn(h), ue(() => {
+    b(), V();
+  }, [t, y, h]), ue(() => b, []), [E, s, v];
+}
+function Cn(e) {
+  ue(() => {
+    const t = e;
+    return window.addEventListener("resize", t), () => void window.removeEventListener("resize", t);
+  }, [e]);
+}
+function Sn(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 cr(e) {
+  const t = [];
+  if (!e || e === document.body)
+    return t;
+  const { overflow: r, overflowX: n, overflowY: a } = window.getComputedStyle(e);
+  return [r, n, a].some((s) => s === "auto" || s === "scroll") && t.push(e), [...t, ...cr(e.parentElement)];
+}
+const En = ["x", "y", "top", "bottom", "left", "right", "width", "height"], Vn = (e, t) => En.every((r) => e[r] === t[r]), ke = ({
+  class: e,
+  ...t
+}) => {
+  const {
+    t: r
+  } = Y();
+  return c("button", {
+    class: je("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: c("svg", {
+      class: "block",
+      width: "16",
+      height: "16",
+      viewBox: "0 0 16 16",
+      fill: "transparent",
+      stroke: "currentColor",
+      "stroke-linecap": "round",
+      "stroke-width": "2",
+      children: [c("title", {
+        children: r("send")
+      }), c("path", {
+        d: "M3.5 7.5L8 3L12.5 7.5"
+      }), c("path", {
+        d: "M8 4V13"
+      })]
+    })
+  });
+}, Fn = 25, ct = lt({
+  instant: () => {
+  },
+  smooth: () => {
+  }
+}), H = {
+  onSubmitSuccessFn$: lt(() => {
+  }),
+  isBotTyping$: lt(!1),
+  scrollToEnd: {
+    instant: () => ct.value.instant(),
+    smooth: () => ct.value.smooth()
+  }
+}, In = () => {
+  const e = ae(null);
+  ye(() => {
+    ct.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 = ft(() => ({
+    addToSubmissions: (n, a) => A.setSubmission(n, a),
+    send: async ({
+      message: n,
+      signal: a,
+      groupId: s
+    }) => {
+      if (await Ge(n).with({
+        author: "bot",
+        type: "text"
+      }, async (o) => {
+        if (a != null && a.aborted)
+          throw new De();
+        H.isBotTyping$.value = !0;
+        const i = Math.min(Math.max(20, o.text.length), 100) * Fn;
+        await new Promise((f) => setTimeout(f, i, {
+          signal: a
+        })), H.isBotTyping$.value = !1;
+      }).otherwise(async () => {
+      }), a != null && a.aborted)
+        throw new De();
+      A.addMessage(n, s);
+    },
+    input: ({
+      input: n,
+      signal: a
+    }) => {
+      if (a != null && a.aborted)
+        throw new De();
+      return A.setInput(n), new Promise((s) => {
+        const o = (i) => {
+          if (a != null && a.aborted)
+            throw new De();
+          A.setInput(void 0), n.key && A.setSubmission(n.key, i), s(i);
+        };
+        H.onSubmitSuccessFn$.value = o;
+      });
+    }
+  }), []);
+  return {
+    chatRef: e,
+    chatService: t
+  };
+}, Ie = ({
+  error: e
+}) => !e || !e.message ? null : c("div", {
+  role: "alert",
+  class: "text-error-11 flex max-w-full items-center gap-1 overflow-hidden rounded-full px-2 py-2",
+  children: [c("svg", {
+    class: "text-error-9 h-4 w-4",
+    viewBox: "0 0 16 16",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: [c("circle", {
+      cx: "8",
+      cy: "8",
+      r: "6.3",
+      stroke: "currentColor",
+      "stroke-width": "1.4"
+    }), c("rect", {
+      x: "7",
+      y: "4",
+      width: "2",
+      height: "5",
+      fill: "currentColor"
+    }), c("rect", {
+      x: "7",
+      y: "10",
+      width: "2",
+      height: "2",
+      fill: "currentColor"
+    })]
+  }), c("p", {
+    class: "truncate pr-1 text-sm",
+    children: e.message
+  })]
+}), _e = ({
+  class: e,
+  ...t
+}) => {
+  const {
+    t: r
+  } = Y();
+  return c("button", {
+    type: "button",
+    class: je("fr touch-hitbox text-neutral-10 bg-neutral-1 ring-divider hover:ring-divider active:ring-interactive-bg-hover hover:text-neutral-12 active:text-neutral-12 hover:bg-divider active:bg-interactive-bg-hover flex flex-shrink-0 items-center justify-center gap-1 self-center rounded-full py-1 pl-2 pr-2.5 text-sm ring-1 transition-all", e),
+    ...t,
+    children: [c("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: [c("title", {
+        children: r("skip")
+      }), c("path", {
+        d: "M3.25 11.25A5 5 0 0 1 12 7"
+      }), c("path", {
+        d: "M13.25 4.5V8.25H9.5"
+      })]
+    }), r("skip")]
+  });
+}, ht = {
+  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"
+}, Ue = Xe("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
+  }
+}), An = "https://api.mapbox.com/search/searchbox/v1/suggest", Mn = "ZzRDWFU0dTZ3SF9aWk9RNGl6QzZaWS5RZmlFak13a0hPbGxXZXlNSGN5RUhObUJ6TXpSV08yUW5OdE5tSTZJU1lpd2lJb1JYYXRObmJ2Tm5iaGhHZWx4V1lpb2pJMUp5ZS5rcA==", Ln = (e) => atob(e).split("").reverse().join(""), le = ge({
+  name: Q()
+}), Nn = ge({
+  suggestions: Rr(ge({
+    full_address: it(Q()),
+    place_formatted: it(Q()),
+    name: it(Q()),
+    mapbox_id: Q(),
+    context: Or(ge({
+      address: le,
+      street: le,
+      neighborhood: le,
+      locality: le,
+      district: le,
+      place: le,
+      region: le,
+      postcode: le,
+      country: le
+    }))
+  }))
+}), Tn = ({
+  logger: e,
+  t
+}) => ft(() => {
+  var n;
+  const r = (n = A.current$.peek().flow) == null ? void 0 : n.data.flowSessionId;
+  return r ? {
+    enabled: !0,
+    getPredictions: async (a) => {
+      var v;
+      const s = new URL(An);
+      s.searchParams.set("q", a), s.searchParams.set("session_token", r);
+      const o = (v = A.current$.peek().flow) == null ? void 0 : v.locationOrigin;
+      o && o.lat !== void 0 && o.lng !== void 0 && o.lat >= -90 && o.lat <= 90 && o.lng >= -180 && o.lng <= 180 && s.searchParams.set("proximity", `${o.lng},${o.lat}`), s.searchParams.set("access_token", Ln(Mn));
+      const f = await fetch(s);
+      if (!f.ok)
+        return e.error("Failed to get address details", f), {
+          ok: !1,
+          error: t("address_error")
+        };
+      const p = Dr(Nn, await f.json());
+      if (p.success === !1)
+        return e.error("Failed to parse address details", p.issues), {
+          ok: !1,
+          error: t("address_error")
+        };
+      const {
+        suggestions: C
+      } = p.output;
+      return {
+        ok: !0,
+        data: C.map((h) => {
+          var y, b, V, E, x, _, I, O, M;
+          return {
+            label: h.full_address ?? h.place_formatted ?? h.name ?? h.mapbox_id,
+            id: h.mapbox_id,
+            address: {
+              line1: ((y = h.context.address) == null ? void 0 : y.name) ?? ((b = h.context.street) == null ? void 0 : b.name),
+              line2: void 0,
+              line3: ((V = h.context.neighborhood) == null ? void 0 : V.name) ?? ((E = h.context.locality) == null ? void 0 : E.name),
+              city: ((x = h.context.place) == null ? void 0 : x.name) ?? ((_ = h.context.district) == null ? void 0 : _.name),
+              state: (I = h.context.region) == null ? void 0 : I.name,
+              postcode: (O = h.context.postcode) == null ? void 0 : O.name,
+              country: (M = h.context.country) == null ? void 0 : M.name
+            }
+          };
+        })
+      };
+    }
+  } : {
+    enabled: !1
+  };
+}, [e, t]), Nt = (e) => {
+  const {
+    t
+  } = Y();
+  return c("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: [c("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: c("path", {
+        d: "M10 3L5 8L10 13"
+      })
+    }), c("span", {
+      children: t("back")
+    })]
+  });
+}, Dn = ({
+  input: e,
+  onSubmitSuccess: t,
+  logger: r
+}) => {
+  const {
+    t: n
+  } = Y(), [a, s] = se(), [o, i] = se([]), {
+    enabled: f,
+    getPredictions: p
+  } = Tn({
+    logger: r,
+    t: n
+  }), [C, v] = se(f ? "query" : "manual"), [h, y] = se(""), [b, V] = se(), E = (x) => {
+    me(f, "Query state should not be enabled"), x = x.trim(), x !== (h == null ? void 0 : h.trim()) && (y(x), x === "" && i([]), V(void 0), p(x).then((_) => {
+      if (_.ok === !1) {
+        i([]), V(_.error);
+        return;
+      }
+      i(_.data);
+    }));
+  };
+  switch (C) {
+    case "query":
+      return me(f, "Query state should not be enabled"), c(Rn, {
+        input: e,
+        onSkip: () => t(null),
+        onAddressSelect: (x) => {
+          if (x === "") {
+            s(void 0), v("manual");
+            return;
+          }
+          const _ = o.find((I) => I.id === x);
+          _ && (s(_.address), v("details"));
+        },
+        onAddressSearch: (x) => {
+          E(x);
+        },
+        suggestions: o,
+        query: h,
+        error: b
+      });
+    case "details":
+      return me(a !== void 0), c(Dt, {
+        input: e,
+        logger: r,
+        onSubmitSuccess: t,
+        addressFields: a,
+        actions: c(Nt, {
+          onClick: () => {
+            v("query");
+          }
+        })
+      });
+    case "manual":
+      return c(Dt, {
+        logger: r,
+        input: e,
+        onSubmitSuccess: t,
+        addressFields: {},
+        actions: f ? c(Nt, {
+          onClick: () => {
+            v("query");
+          }
+        }) : void 0
+      });
+  }
+}, Rn = ({
+  input: e,
+  onSkip: t,
+  suggestions: r,
+  onAddressSelect: n,
+  query: a,
+  onAddressSearch: s,
+  error: o
+}) => {
+  const {
+    t: i
+  } = Y(), f = ae(null);
+  return ye(() => {
+    f.current && (f.current.focus(), f.current.select());
+  }, []), c(we, {
+    children: [c("form", {
+      noValidate: !0,
+      onSubmit: (p) => {
+        p.preventDefault();
+        const v = new FormData(p.currentTarget).get("address");
+        typeof v == "string" && s(v);
+      },
+      class: "flex gap-2 p-2.5",
+      children: [c("div", {
+        class: "group relative flex-1",
+        children: [c("input", {
+          ref: f,
+          name: "address",
+          id: "chat-address",
+          autocomplete: "address-line1 country-name postal-code",
+          autoFocus: !0,
+          placeholder: e.config.placeholder || i("address_search"),
+          defaultValue: a,
+          class: Ue({
+            optional: !!e.config.optional,
+            className: "w-full rounded-full"
+          })
+        }), c("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: c("svg", {
+            width: "16",
+            height: "16",
+            viewBox: "0 0 16 16",
+            fill: "none",
+            xmlns: "http://www.w3.org/2000/svg",
+            children: [c("g", {
+              id: "inploi",
+              stroke: "currentColor",
+              "stroke-linecap": "round",
+              "stroke-linejoin": "round",
+              strokeWidth: "1.5",
+              children: [c("circle", {
+                cx: "7",
+                cy: "7",
+                r: "4"
+              }), c("path", {
+                d: "M10 10L13 13"
+              })]
+            }), c("span", {
+              class: "sr-only",
+              children: i("search")
+            })]
+          })
+        })]
+      }), e.config.optional && c(_e, {
+        class: "relative",
+        onClick: t
+      })]
+    }), o ? c(Ie, {
+      error: {
+        message: o
+      }
+    }) : null, c("ul", {
+      children: [r.map((p) => c("li", {
+        children: c("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(p.id);
+          },
+          children: [c("span", {
+            class: "flex-grow",
+            children: p.label
+          }), c("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: c("path", {
+              d: "M6 3L11 8L6 13"
+            })
+          })]
+        })
+      }, p.id)), c("li", {
+        children: c("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: c("span", {
+            class: "flex-grow",
+            children: i("address_manual")
+          })
+        })
+      }, "")]
+    })]
+  });
+}, Tt = ["line1", "line2", "line3", "city", "state", "postcode", "country"], Dt = ({
+  addressFields: e,
+  onSubmitSuccess: t,
+  actions: r,
+  input: n
+}) => {
+  const a = ae(null);
+  ye(() => {
+    if (a.current) {
+      const i = a.current.querySelector("input");
+      i && (i.focus(), i.select());
+    }
+  }, []);
+  const s = Object.keys(ht), {
+    t: o
+  } = Y();
+  return c("form", {
+    class: "bg-neutral-1/90 flex flex-col justify-end gap-2 p-2",
+    onSubmit: (i) => {
+      const f = new FormData(i.currentTarget), p = Object.fromEntries(f.entries());
+      t({
+        type: "address",
+        value: p
+      });
+    },
+    children: [c("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: a,
+      children: Tt.map((i, f) => {
+        const p = `isdk_${i}`, C = n.config.keys[i];
+        return C ? c(we, {
+          children: [c("label", {
+            for: p,
+            class: "text-neutral-9 [&:has(+*>input:focus)]:text-neutral-11 w-24 pb-2 text-xs uppercase leading-3 tracking-widest transition-colors",
+            children: o(i)
+          }), c("div", {
+            class: "flex flex-col items-stretch gap-1.5",
+            children: [i === "country" ? c("div", {
+              class: "relative",
+              children: [c("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: C,
+                id: p,
+                defaultValue: e[i],
+                required: !0,
+                children: [e.country && !s.includes(e.country) ? c("option", {
+                  value: e[i],
+                  children: e[i]
+                }) : c("option", {
+                  value: "",
+                  children: o("select_country")
+                }), s.map((v) => c("option", {
+                  value: v,
+                  children: v
+                }, v))]
+              }), c("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: c("path", {
+                  d: "M4 6.5L8 10.5L12 6.5"
+                })
+              })]
+            }) : c("input", {
+              autoFocus: f === 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: C,
+              id: p,
+              defaultValue: e[i],
+              required: !0
+            }), f === Tt.length - 1 ? c("hr", {
+              class: "m-0 w-full border-b border-b-transparent"
+            }) : c("hr", {
+              class: "border-b-neutral-5 m-0 w-full border-b border-solid"
+            })]
+          })]
+        }) : null;
+      })
+    }), c("div", {
+      class: "flex w-full flex-1 ",
+      children: [c("div", {
+        class: "flex-grow",
+        children: r
+      }), c(ke, {
+        class: "flex items-center justify-center"
+      })]
+    })]
+  });
+}, pt = () => {
+  const e = ae(null);
+  return ue(() => {
+    var t;
+    (t = e.current) == null || t.focus();
+  }, []), e;
+}, ur = ["true", "false"], On = $r(ur), Bn = "answer", dr = "flex items-center flex-wrap gap-2 p-2.5", fr = "min-w-0 max-w-full flex-auto", hr = sr(({
+  label: e,
+  ...t
+}, r) => c("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 py-2.5 ring-2 transition-all selection:bg-transparent",
+  ...t,
+  ref: r,
+  children: c("p", {
+    class: "text-center text-base",
+    children: e
+  })
+})), Pn = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  const r = pt();
+  return c("form", {
+    noValidate: !0,
+    class: "",
+    onSubmit: (n) => {
+      n.preventDefault();
+      const a = Br(n).value, s = Pr(On, a);
+      t({
+        type: "boolean",
+        value: s === "true"
+      });
+    },
+    children: [c("ul", {
+      class: dr,
+      children: ur.map((n, a) => c("li", {
+        class: fr,
+        children: c(hr, {
+          ref: a === 0 ? r : null,
+          type: "submit",
+          name: Bn,
+          value: n,
+          label: e.config.labels[n]
+        }, n)
+      }))
+    }), e.config.optional && c("div", {
+      class: "px-2 pb-2",
+      children: c(_e, {
+        class: "relative w-full",
+        type: "button",
+        onClick: () => t(null)
+      })
+    })]
+  });
+}, $n = (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;
+}), jn = (e) => e.reduce((t, r) => t + r.sizeKb, 0), Un = Fe("file"), Rt = 3, zn = ({
+  file: e,
+  class: t,
+  ...r
+}) => {
+  const n = e.name.split(".").pop(), a = e.name.replace(new RegExp(`.${n}$`), "");
+  return c("div", {
+    class: je("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: [c("p", {
+      "aria-label": "File name",
+      class: "text-accent-12 flex flex-grow overflow-hidden",
+      children: [c("span", {
+        class: "block truncate",
+        children: a
+      }), c("span", {
+        children: [".", n]
+      })]
+    }), c("p", {
+      "aria-label": "File size",
+      class: "text-accent-11",
+      children: Oe(e.sizeKb)
+    })]
+  });
+}, Ot = ({
+  class: e,
+  ...t
+}) => c("li", {
+  class: je("outline-neutral-6 text-neutral-11 bg-neutral-1 block rounded-md px-1 py-0.5 text-xs outline outline-1", e),
+  ...t
+}), pr = (e) => {
+  const t = e.split(".").pop();
+  if (!t)
+    throw new Error("No file extension found");
+  return t ? "." + t : "";
+}, qn = ({
+  allowedExtensions: e,
+  files: t
+}) => {
+  const r = e.map((n) => n.toLowerCase());
+  return t.every((n) => r.includes(pr(n.name).toLowerCase()));
+}, Hn = (e, t) => {
+  const r = pr(e);
+  return `${e.replace(new RegExp(`${r}$`), "").slice(0, t)}${r}`;
+}, Kn = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  var v;
+  const r = (v = A.current$.value.flow) == null ? void 0 : v.data.submissions[e.key], [n, a] = se(Un(r) ? r.value : []), [s, o] = se(), i = n.length - Rt, f = jn(n), p = pt(), {
+    t: C
+  } = Y();
+  return c("form", {
+    class: "flex flex-col gap-1 p-2.5",
+    onSubmit: (h) => (h.preventDefault(), o(void 0), n.length === 0 ? o({
+      type: "required",
+      message: C("validation_file")
+    }) : e.config.extensions.length > 0 && !qn({
+      allowedExtensions: e.config.extensions,
+      files: n
+    }) ? o({
+      type: "validate",
+      message: `${C("validation_file_ext", {
+        ext: e.config.extensions.join(", ")
+      })}`
+    }) : e.config.fileSizeLimitKib && f > e.config.fileSizeLimitKib ? o({
+      type: "max",
+      message: `File size exceeds limit of ${Oe(e.config.fileSizeLimitKib)}`
+    }) : e.config.allowMultiple === !1 && n.length > 1 ? o({
+      type: "invalid",
+      message: C("validation_file_max", {
+        count: 1
+      })
+    }) : t({
+      type: "file",
+      value: n
+    })),
+    children: [c("div", {
+      class: "flex items-center gap-2",
+      children: [c("label", {
+        ref: p,
+        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 ? c(we, {
+          children: [c("ul", {
+            class: "flex max-w-full flex-wrap justify-center gap-1 overflow-hidden p-1",
+            children: [n.slice(0, Rt).map((h) => {
+              const y = h.name.split(".").pop(), b = h.name.replace(new RegExp(`.${y}$`), "");
+              return c(Ot, {
+                class: "flex overflow-hidden",
+                children: [c("span", {
+                  class: "block truncate",
+                  children: b
+                }), c("span", {
+                  children: [".", y]
+                })]
+              });
+            }), i > 0 ? c(Ot, {
+              children: ["+", i, " file", i !== 1 ? "s" : ""]
+            }) : null]
+          }), c("p", {
+            class: "text-neutral-11 text-xs",
+            children: [Oe(f), " ", n.length > 1 ? "total" : ""]
+          })]
+        }) : c("div", {
+          class: "flex flex-col justify-center gap-4 pb-6 pt-5",
+          children: [c("header", {
+            class: "flex flex-col items-center gap-0",
+            children: [c("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: c("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"
+              })
+            }), c("p", {
+              class: "text-neutral-12 tracking-[-0.01em]",
+              children: C("upload_file", {
+                count: e.config.allowMultiple ? 2 : 1
+              })
+            }), e.config.fileSizeLimitKib ? c("p", {
+              class: "text-neutral-10 text-xs",
+              children: ["(", C("file_max_size", {
+                size: Oe(e.config.fileSizeLimitKib)
+              }), ")"]
+            }) : null]
+          }), c("aside", {
+            class: "flex flex-col items-center gap-2",
+            children: [c("p", {
+              id: "accepted-filetypes",
+              class: "sr-only",
+              children: C("file_extensions")
+            }), c("ul", {
+              "aria-describedby": "accepted-filetypes",
+              class: "flex flex-wrap justify-center gap-2",
+              children: e.config.extensions.map((h) => c("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: h.replace(".", "")
+              }))
+            })]
+          })]
+        }), c("input", {
+          id: "dropzone-file",
+          onInput: async (h) => {
+            me(h.target instanceof HTMLInputElement);
+            const y = h.target.files ? Array.from(h.target.files) : [], b = await Promise.allSettled(y.map(async (E) => {
+              const x = await $n(E);
+              return {
+                name: Hn(E.name, 42),
+                data: x,
+                sizeKb: E.size / 1e3
+              };
+            }));
+            if (b.some(({
+              status: E
+            }) => E === "rejected"))
+              return o({
+                type: "invalid",
+                message: "Invalid file"
+              });
+            const V = b.map((E) => E.status === "fulfilled" ? E.value : null).filter(Boolean);
+            a(V);
+          },
+          multiple: e.config.allowMultiple,
+          type: "file",
+          class: "sr-only"
+        })]
+      }), c("div", {
+        class: "flex h-full flex-col items-center gap-2",
+        children: [c(ke, {
+          disabled: n.length === 0
+        }), e.config.optional && c(_e, {
+          class: "relative",
+          onClick: () => t(null)
+        })]
+      })]
+    }), c(Ie, {
+      error: s
+    })]
+  });
+};
+var ze = (e) => e.type === "checkbox", xe = (e) => e instanceof Date, J = (e) => e == null;
+const mr = (e) => typeof e == "object";
+var $ = (e) => !J(e) && !Array.isArray(e) && mr(e) && !xe(e), Gn = (e) => $(e) && e.target ? ze(e.target) ? e.target.checked : e.target.value : e, Wn = (e) => e.substring(0, e.search(/\.\d+(\.|$)/)) || e, Jn = (e, t) => e.has(Wn(t)), Xn = (e) => {
+  const t = e.constructor && e.constructor.prototype;
+  return $(t) && t.hasOwnProperty("isPrototypeOf");
+}, mt = typeof window < "u" && typeof window.HTMLElement < "u" && typeof document < "u";
+function U(e) {
+  if (e instanceof Date)
+    return new Date(e);
+  const t = typeof FileList < "u" && e instanceof FileList;
+  if (mt && (e instanceof Blob || t))
+    return e;
+  const r = Array.isArray(e);
+  if (!r && !($(e) && Xn(e)))
+    return e;
+  const n = r ? [] : Object.create(Object.getPrototypeOf(e));
+  for (const a in e)
+    Object.prototype.hasOwnProperty.call(e, a) && (n[a] = U(e[a]));
+  return n;
+}
+var Ye = (e) => /^\w*$/.test(e), B = (e) => e === void 0, gt = (e) => Array.isArray(e) ? e.filter(Boolean) : [], yt = (e) => gt(e.replace(/["|']|\]/g, "").split(/\.|\[/)), k = (e, t, r) => {
+  if (!t || !$(e))
+    return r;
+  const n = (Ye(t) ? [t] : yt(t)).reduce((a, s) => J(a) ? a : a[s], e);
+  return B(n) || n === e ? B(e[t]) ? r : e[t] : n;
+}, ne = (e) => typeof e == "boolean", te = (e) => typeof e == "function", D = (e, t, r) => {
+  let n = -1;
+  const a = Ye(t) ? [t] : yt(t), s = a.length, o = s - 1;
+  for (; ++n < s; ) {
+    const i = a[n];
+    let f = r;
+    if (n !== o) {
+      const p = e[i];
+      f = $(p) || Array.isArray(p) ? p : isNaN(+a[n + 1]) ? {} : [];
+    }
+    if (i === "__proto__" || i === "constructor" || i === "prototype")
+      return;
+    e[i] = f, e = e[i];
+  }
+};
+const Bt = {
+  BLUR: "blur",
+  FOCUS_OUT: "focusout",
+  CHANGE: "change"
+}, re = {
+  onBlur: "onBlur",
+  onChange: "onChange",
+  onSubmit: "onSubmit",
+  onTouched: "onTouched",
+  all: "all"
+}, ce = {
+  max: "max",
+  min: "min",
+  maxLength: "maxLength",
+  minLength: "minLength",
+  pattern: "pattern",
+  required: "required",
+  validate: "validate"
+}, Zn = G.createContext(null);
+Zn.displayName = "HookFormControlContext";
+var Yn = (e, t, r, n = !0) => {
+  const a = {
+    defaultValues: t._defaultValues
+  };
+  for (const s in e)
+    Object.defineProperty(a, s, {
+      get: () => {
+        const o = s;
+        return t._proxyFormState[o] !== re.all && (t._proxyFormState[o] = !n || re.all), r && (r[o] = !0), e[o];
+      }
+    });
+  return a;
+};
+const Qn = typeof window < "u" ? G.useLayoutEffect : G.useEffect;
+var Z = (e) => typeof e == "string", es = (e, t, r, n, a) => Z(e) ? (n && t.watch.add(e), k(r, e, a)) : Array.isArray(e) ? e.map((s) => (n && t.watch.add(s), k(r, s))) : (n && (t.watchAll = !0), r), ut = (e) => J(e) || !mr(e);
+function he(e, t, r = /* @__PURE__ */ new WeakSet()) {
+  if (ut(e) || ut(t))
+    return Object.is(e, t);
+  if (xe(e) && xe(t))
+    return Object.is(e.getTime(), t.getTime());
+  const n = Object.keys(e), a = Object.keys(t);
+  if (n.length !== a.length)
+    return !1;
+  if (r.has(e) || r.has(t))
+    return !0;
+  r.add(e), r.add(t);
+  for (const s of n) {
+    const o = e[s];
+    if (!a.includes(s))
+      return !1;
+    if (s !== "ref") {
+      const i = t[s];
+      if (xe(o) && xe(i) || $(o) && $(i) || Array.isArray(o) && Array.isArray(i) ? !he(o, i, r) : !Object.is(o, i))
+        return !1;
+    }
+  }
+  return !0;
+}
+const ts = G.createContext(null);
+ts.displayName = "HookFormContext";
+var gr = (e, t, r, n, a) => t ? {
+  ...r[e],
+  types: {
+    ...r[e] && r[e].types ? r[e].types : {},
+    [n]: a || !0
+  }
+} : {}, Pe = (e) => Array.isArray(e) ? e : [e], Pt = () => {
+  let e = [];
+  return {
+    get observers() {
+      return e;
+    },
+    next: (a) => {
+      for (const s of e)
+        s.next && s.next(a);
+    },
+    subscribe: (a) => (e.push(a), {
+      unsubscribe: () => {
+        e = e.filter((s) => s !== a);
+      }
+    }),
+    unsubscribe: () => {
+      e = [];
+    }
+  };
+};
+function yr(e, t) {
+  const r = {};
+  for (const n in e)
+    if (e.hasOwnProperty(n)) {
+      const a = e[n], s = t[n];
+      if (a && $(a) && s) {
+        const o = yr(a, s);
+        $(o) && (r[n] = o);
+      } else
+        e[n] && (r[n] = s);
+    }
+  return r;
+}
+var W = (e) => $(e) && !Object.keys(e).length, bt = (e) => e.type === "file", We = (e) => {
+  if (!mt)
+    return !1;
+  const t = e ? e.ownerDocument : 0;
+  return e instanceof (t && t.defaultView ? t.defaultView.HTMLElement : HTMLElement);
+}, br = (e) => e.type === "select-multiple", vt = (e) => e.type === "radio", rs = (e) => vt(e) || ze(e), ot = (e) => We(e) && e.isConnected;
+function ns(e, t) {
+  const r = t.slice(0, -1).length;
+  let n = 0;
+  for (; n < r; )
+    e = B(e) ? n++ : e[t[n++]];
+  return e;
+}
+function ss(e) {
+  for (const t in e)
+    if (e.hasOwnProperty(t) && !B(e[t]))
+      return !1;
+  return !0;
+}
+function P(e, t) {
+  const r = Array.isArray(t) ? t : Ye(t) ? [t] : yt(t), n = r.length === 1 ? e : ns(e, r), a = r.length - 1, s = r[a];
+  return n && delete n[s], a !== 0 && ($(n) && W(n) || Array.isArray(n) && ss(n)) && P(e, r.slice(0, -1)), e;
+}
+var as = (e) => {
+  for (const t in e)
+    if (te(e[t]))
+      return !0;
+  return !1;
+};
+function vr(e) {
+  return Array.isArray(e) || $(e) && !as(e);
+}
+function dt(e, t = {}) {
+  for (const r in e) {
+    const n = e[r];
+    vr(n) ? (t[r] = Array.isArray(n) ? [] : {}, dt(n, t[r])) : B(n) || (t[r] = !0);
+  }
+  return t;
+}
+function Ve(e, t, r) {
+  r || (r = dt(t));
+  for (const n in e) {
+    const a = e[n];
+    if (vr(a))
+      B(t) || ut(r[n]) ? r[n] = dt(a, Array.isArray(a) ? [] : {}) : Ve(a, J(t) ? {} : t[n], r[n]);
+    else {
+      const s = t[n];
+      r[n] = !he(a, s);
+    }
+  }
+  return r;
+}
+const $t = {
+  value: !1,
+  isValid: !1
+}, jt = { value: !0, isValid: !0 };
+var xr = (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 && !B(e[0].attributes.value) ? B(e[0].value) || e[0].value === "" ? jt : { value: e[0].value, isValid: !0 } : jt
+    ) : $t;
+  }
+  return $t;
+}, wr = (e, { valueAsNumber: t, valueAsDate: r, setValueAs: n }) => B(e) ? e : t ? e === "" ? NaN : e && +e : r && Z(e) ? new Date(e) : n ? n(e) : e;
+const Ut = {
+  isValid: !1,
+  value: null
+};
+var kr = (e) => Array.isArray(e) ? e.reduce((t, r) => r && r.checked && !r.disabled ? {
+  isValid: !0,
+  value: r.value
+} : t, Ut) : Ut;
+function zt(e) {
+  const t = e.ref;
+  return bt(t) ? t.files : vt(t) ? kr(e.refs).value : br(t) ? [...t.selectedOptions].map(({ value: r }) => r) : ze(t) ? xr(e.refs).value : wr(B(t.value) ? e.ref.value : t.value, e);
+}
+var is = (e, t, r, n) => {
+  const a = {};
+  for (const s of e) {
+    const o = k(t, s);
+    o && D(a, s, o._f);
+  }
+  return {
+    criteriaMode: r,
+    names: [...e],
+    fields: a,
+    shouldUseNativeValidation: n
+  };
+}, Je = (e) => e instanceof RegExp, Ne = (e) => B(e) ? e : Je(e) ? e.source : $(e) ? Je(e.value) ? e.value.source : e.value : e, qt = (e) => ({
+  isOnSubmit: !e || e === re.onSubmit,
+  isOnBlur: e === re.onBlur,
+  isOnChange: e === re.onChange,
+  isOnAll: e === re.all,
+  isOnTouch: e === re.onTouched
+});
+const Ht = "AsyncFunction";
+var os = (e) => !!e && !!e.validate && !!(te(e.validate) && e.validate.constructor.name === Ht || $(e.validate) && Object.values(e.validate).find((t) => t.constructor.name === Ht)), ls = (e) => e.mount && (e.required || e.min || e.max || e.maxLength || e.minLength || e.pattern || e.validate), Kt = (e, t, r) => !r && (t.watchAll || t.watch.has(e) || [...t.watch].some((n) => e.startsWith(n) && /^\.\w+/.test(e.slice(n.length))));
+const $e = (e, t, r, n) => {
+  for (const a of r || Object.keys(e)) {
+    const s = k(e, a);
+    if (s) {
+      const { _f: o, ...i } = s;
+      if (o) {
+        if (o.refs && o.refs[0] && t(o.refs[0], a) && !n)
+          return !0;
+        if (o.ref && t(o.ref, o.name) && !n)
+          return !0;
+        if ($e(i, t))
+          break;
+      } else if ($(i) && $e(i, t))
+        break;
+    }
+  }
+};
+function Gt(e, t, r) {
+  const n = k(e, r);
+  if (n || Ye(r))
+    return {
+      error: n,
+      name: r
+    };
+  const a = r.split(".");
+  for (; a.length; ) {
+    const s = a.join("."), o = k(t, s), i = k(e, s);
+    if (o && !Array.isArray(o) && r !== s)
+      return { name: r };
+    if (i && i.type)
+      return {
+        name: s,
+        error: i
+      };
+    if (i && i.root && i.root.type)
+      return {
+        name: `${s}.root`,
+        error: i.root
+      };
+    a.pop();
+  }
+  return {
+    name: r
+  };
+}
+var cs = (e, t, r, n) => {
+  r(e);
+  const { name: a, ...s } = e;
+  return W(s) || Object.keys(s).length >= Object.keys(t).length || Object.keys(s).find((o) => t[o] === (!n || re.all));
+}, us = (e, t, r) => !e || !t || e === t || Pe(e).some((n) => n && (r ? n === t : n.startsWith(t) || t.startsWith(n))), ds = (e, t, r, n, a) => a.isOnAll ? !1 : !r && a.isOnTouch ? !(t || e) : (r ? n.isOnBlur : a.isOnBlur) ? !e : (r ? n.isOnChange : a.isOnChange) ? e : !0, fs = (e, t) => !gt(k(e, t)).length && P(e, t), hs = (e, t, r) => {
+  const n = Pe(k(e, r));
+  return D(n, "root", t[r]), D(e, r, n), e;
+};
+function Wt(e, t, r = "validate") {
+  if (Z(e) || Array.isArray(e) && e.every(Z) || ne(e) && !e)
+    return {
+      type: r,
+      message: Z(e) ? e : "",
+      ref: t
+    };
+}
+var Se = (e) => $(e) && !Je(e) ? e : {
+  value: e,
+  message: ""
+}, Jt = async (e, t, r, n, a, s) => {
+  const { ref: o, refs: i, required: f, maxLength: p, minLength: C, min: v, max: h, pattern: y, validate: b, name: V, valueAsNumber: E, mount: x } = e._f, _ = k(r, V);
+  if (!x || t.has(V))
+    return {};
+  const I = i ? i[0] : o, O = (F) => {
+    a && I.reportValidity && (I.setCustomValidity(ne(F) ? "" : F || ""), I.reportValidity());
+  }, M = {}, be = vt(o), Ce = ze(o), oe = be || Ce, de = (E || bt(o)) && B(o.value) && B(_) || We(o) && o.value === "" || _ === "" || Array.isArray(_) && !_.length, z = gr.bind(null, V, n, M), qe = (F, L, j, q = ce.maxLength, ee = ce.minLength) => {
+    const X = F ? L : j;
+    M[V] = {
+      type: F ? q : ee,
+      message: X,
+      ref: o,
+      ...z(F ? q : ee, X)
+    };
+  };
+  if (s ? !Array.isArray(_) || !_.length : f && (!oe && (de || J(_)) || ne(_) && !_ || Ce && !xr(i).isValid || be && !kr(i).isValid)) {
+    const { value: F, message: L } = Z(f) ? { value: !!f, message: f } : Se(f);
+    if (F && (M[V] = {
+      type: ce.required,
+      message: L,
+      ref: I,
+      ...z(ce.required, L)
+    }, !n))
+      return O(L), M;
+  }
+  if (!de && (!J(v) || !J(h))) {
+    let F, L;
+    const j = Se(h), q = Se(v);
+    if (!J(_) && !isNaN(_)) {
+      const ee = o.valueAsNumber || _ && +_;
+      J(j.value) || (F = ee > j.value), J(q.value) || (L = ee < q.value);
+    } else {
+      const ee = o.valueAsDate || new Date(_), X = (Le) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + Le), Ae = o.type == "time", Me = o.type == "week";
+      Z(j.value) && _ && (F = Ae ? X(_) > X(j.value) : Me ? _ > j.value : ee > new Date(j.value)), Z(q.value) && _ && (L = Ae ? X(_) < X(q.value) : Me ? _ < q.value : ee < new Date(q.value));
+    }
+    if ((F || L) && (qe(!!F, j.message, q.message, ce.max, ce.min), !n))
+      return O(M[V].message), M;
+  }
+  if ((p || C) && !de && (Z(_) || s && Array.isArray(_))) {
+    const F = Se(p), L = Se(C), j = !J(F.value) && _.length > +F.value, q = !J(L.value) && _.length < +L.value;
+    if ((j || q) && (qe(j, F.message, L.message), !n))
+      return O(M[V].message), M;
+  }
+  if (y && !de && Z(_)) {
+    const { value: F, message: L } = Se(y);
+    if (Je(F) && !_.match(F) && (M[V] = {
+      type: ce.pattern,
+      message: L,
+      ref: o,
+      ...z(ce.pattern, L)
+    }, !n))
+      return O(L), M;
+  }
+  if (b) {
+    if (te(b)) {
+      const F = await b(_, r), L = Wt(F, I);
+      if (L && (M[V] = {
+        ...L,
+        ...z(ce.validate, L.message)
+      }, !n))
+        return O(L.message), M;
+    } else if ($(b)) {
+      let F = {};
+      for (const L in b) {
+        if (!W(F) && !n)
+          break;
+        const j = Wt(await b[L](_, r), I, L);
+        j && (F = {
+          ...j,
+          ...z(L, j.message)
+        }, O(j.message), n && (M[V] = F));
+      }
+      if (!W(F) && (M[V] = {
+        ref: I,
+        ...F
+      }, !n))
+        return M;
+    }
+  }
+  return O(!0), M;
+};
+const ps = {
+  mode: re.onSubmit,
+  reValidateMode: re.onChange,
+  shouldFocusError: !0
+};
+function ms(e = {}) {
+  let t = {
+    ...ps,
+    ...e
+  }, r = {
+    submitCount: 0,
+    isDirty: !1,
+    isReady: !1,
+    isLoading: te(t.defaultValues),
+    isValidating: !1,
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    touchedFields: {},
+    dirtyFields: {},
+    validatingFields: {},
+    errors: t.errors || {},
+    disabled: t.disabled || !1
+  }, n = {}, a = $(t.defaultValues) || $(t.values) ? U(t.defaultValues || t.values) || {} : {}, s = t.shouldUnregister ? {} : U(a), o = {
+    action: !1,
+    mount: !1,
+    watch: !1,
+    keepIsValid: !1
+  }, i = {
+    mount: /* @__PURE__ */ new Set(),
+    disabled: /* @__PURE__ */ new Set(),
+    unMount: /* @__PURE__ */ new Set(),
+    array: /* @__PURE__ */ new Set(),
+    watch: /* @__PURE__ */ new Set()
+  }, f, p = 0;
+  const C = {
+    isDirty: !1,
+    dirtyFields: !1,
+    validatingFields: !1,
+    touchedFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  }, v = {
+    ...C
+  };
+  let h = {
+    ...v
+  };
+  const y = {
+    array: Pt(),
+    state: Pt()
+  }, b = t.criteriaMode === re.all, V = (l) => (u) => {
+    clearTimeout(p), p = setTimeout(l, u);
+  }, E = async (l) => {
+    if (!o.keepIsValid && !t.disabled && (v.isValid || h.isValid || l)) {
+      let u;
+      t.resolver ? (u = W((await oe()).errors), x()) : u = await z(n, !0), u !== r.isValid && y.state.next({
+        isValid: u
+      });
+    }
+  }, x = (l, u) => {
+    !t.disabled && (v.isValidating || v.validatingFields || h.isValidating || h.validatingFields) && ((l || Array.from(i.mount)).forEach((d) => {
+      d && (u ? D(r.validatingFields, d, u) : P(r.validatingFields, d));
+    }), y.state.next({
+      validatingFields: r.validatingFields,
+      isValidating: !W(r.validatingFields)
+    }));
+  }, _ = (l, u = [], d, w, g = !0, m = !0) => {
+    if (w && d && !t.disabled) {
+      if (o.action = !0, m && Array.isArray(k(n, l))) {
+        const S = d(k(n, l), w.argA, w.argB);
+        g && D(n, l, S);
+      }
+      if (m && Array.isArray(k(r.errors, l))) {
+        const S = d(k(r.errors, l), w.argA, w.argB);
+        g && D(r.errors, l, S), fs(r.errors, l);
+      }
+      if ((v.touchedFields || h.touchedFields) && m && Array.isArray(k(r.touchedFields, l))) {
+        const S = d(k(r.touchedFields, l), w.argA, w.argB);
+        g && D(r.touchedFields, l, S);
+      }
+      (v.dirtyFields || h.dirtyFields) && (r.dirtyFields = Ve(a, s)), y.state.next({
+        name: l,
+        isDirty: F(l, u),
+        dirtyFields: r.dirtyFields,
+        errors: r.errors,
+        isValid: r.isValid
+      });
+    } else
+      D(s, l, u);
+  }, I = (l, u) => {
+    D(r.errors, l, u), y.state.next({
+      errors: r.errors
+    });
+  }, O = (l) => {
+    r.errors = l, y.state.next({
+      errors: r.errors,
+      isValid: !1
+    });
+  }, M = (l, u, d, w) => {
+    const g = k(n, l);
+    if (g) {
+      const m = k(s, l, B(d) ? k(a, l) : d);
+      B(m) || w && w.defaultChecked || u ? D(s, l, u ? m : zt(g._f)) : q(l, m), o.mount && !o.action && E();
+    }
+  }, be = (l, u, d, w, g) => {
+    let m = !1, S = !1;
+    const N = {
+      name: l
+    };
+    if (!t.disabled) {
+      if (!d || w) {
+        (v.isDirty || h.isDirty) && (S = r.isDirty, r.isDirty = N.isDirty = F(), m = S !== N.isDirty);
+        const T = he(k(a, l), u);
+        S = !!k(r.dirtyFields, l), T ? P(r.dirtyFields, l) : D(r.dirtyFields, l, !0), N.dirtyFields = r.dirtyFields, m = m || (v.dirtyFields || h.dirtyFields) && S !== !T;
+      }
+      if (d) {
+        const T = k(r.touchedFields, l);
+        T || (D(r.touchedFields, l, d), N.touchedFields = r.touchedFields, m = m || (v.touchedFields || h.touchedFields) && T !== d);
+      }
+      m && g && y.state.next(N);
+    }
+    return m ? N : {};
+  }, Ce = (l, u, d, w) => {
+    const g = k(r.errors, l), m = (v.isValid || h.isValid) && ne(u) && r.isValid !== u;
+    if (t.delayError && d ? (f = V(() => I(l, d)), f(t.delayError)) : (clearTimeout(p), f = null, d ? D(r.errors, l, d) : P(r.errors, l)), (d ? !he(g, d) : g) || !W(w) || m) {
+      const S = {
+        ...w,
+        ...m && ne(u) ? { isValid: u } : {},
+        errors: r.errors,
+        name: l
+      };
+      r = {
+        ...r,
+        ...S
+      }, y.state.next(S);
+    }
+  }, oe = async (l) => (x(l, !0), await t.resolver(s, t.context, is(l || i.mount, n, t.criteriaMode, t.shouldUseNativeValidation))), de = async (l) => {
+    const { errors: u } = await oe(l);
+    if (x(l), l)
+      for (const d of l) {
+        const w = k(u, d);
+        w ? D(r.errors, d, w) : P(r.errors, d);
+      }
+    else
+      r.errors = u;
+    return u;
+  }, z = async (l, u, d = {
+    valid: !0
+  }) => {
+    for (const w in l) {
+      const g = l[w];
+      if (g) {
+        const { _f: m, ...S } = g;
+        if (m) {
+          const N = i.array.has(m.name), T = g._f && os(g._f);
+          T && v.validatingFields && x([m.name], !0);
+          const K = await Jt(g, i.disabled, s, b, t.shouldUseNativeValidation && !u, N);
+          if (T && v.validatingFields && x([m.name]), K[m.name] && (d.valid = !1, u || e.shouldUseNativeValidation))
+            break;
+          !u && (k(K, m.name) ? N ? hs(r.errors, K, m.name) : D(r.errors, m.name, K[m.name]) : P(r.errors, m.name));
+        }
+        !W(S) && await z(S, u, d);
+      }
+    }
+    return d.valid;
+  }, qe = () => {
+    for (const l of i.unMount) {
+      const u = k(n, l);
+      u && (u._f.refs ? u._f.refs.every((d) => !ot(d)) : !ot(u._f.ref)) && tt(l);
+    }
+    i.unMount = /* @__PURE__ */ new Set();
+  }, F = (l, u) => !t.disabled && (l && u && D(s, l, u), !he(xt(), a)), L = (l, u, d) => es(l, i, {
+    ...o.mount ? s : B(u) ? a : Z(l) ? { [l]: u } : u
+  }, d, u), j = (l) => gt(k(o.mount ? s : a, l, t.shouldUnregister ? k(a, l, []) : [])), q = (l, u, d = {}) => {
+    const w = k(n, l);
+    let g = u;
+    if (w) {
+      const m = w._f;
+      m && (!m.disabled && D(s, l, wr(u, m)), g = We(m.ref) && J(u) ? "" : u, br(m.ref) ? [...m.ref.options].forEach((S) => S.selected = g.includes(S.value)) : m.refs ? ze(m.ref) ? m.refs.forEach((S) => {
+        (!S.defaultChecked || !S.disabled) && (Array.isArray(g) ? S.checked = !!g.find((N) => N === S.value) : S.checked = g === S.value || !!g);
+      }) : m.refs.forEach((S) => S.checked = S.value === g) : bt(m.ref) ? m.ref.value = "" : (m.ref.value = g, m.ref.type || y.state.next({
+        name: l,
+        values: U(s)
+      })));
+    }
+    (d.shouldDirty || d.shouldTouch) && be(l, g, d.shouldTouch, d.shouldDirty, !0), d.shouldValidate && Le(l);
+  }, ee = (l, u, d) => {
+    for (const w in u) {
+      if (!u.hasOwnProperty(w))
+        return;
+      const g = u[w], m = l + "." + w, S = k(n, m);
+      (i.array.has(l) || $(g) || S && !S._f) && !xe(g) ? ee(m, g, d) : q(m, g, d);
+    }
+  }, X = (l, u, d = {}) => {
+    const w = k(n, l), g = i.array.has(l), m = U(u);
+    D(s, l, m), g ? (y.array.next({
+      name: l,
+      values: U(s)
+    }), (v.isDirty || v.dirtyFields || h.isDirty || h.dirtyFields) && d.shouldDirty && y.state.next({
+      name: l,
+      dirtyFields: Ve(a, s),
+      isDirty: F(l, m)
+    })) : w && !w._f && !J(m) ? ee(l, m, d) : q(l, m, d), Kt(l, i) ? y.state.next({
+      ...r,
+      name: l,
+      values: U(s)
+    }) : y.state.next({
+      name: o.mount ? l : void 0,
+      values: U(s)
+    });
+  }, Ae = async (l) => {
+    o.mount = !0;
+    const u = l.target;
+    let d = u.name, w = !0;
+    const g = k(n, d), m = (T) => {
+      w = Number.isNaN(T) || xe(T) && isNaN(T.getTime()) || he(T, k(s, d, T));
+    }, S = qt(t.mode), N = qt(t.reValidateMode);
+    if (g) {
+      let T, K;
+      const ve = u.type ? zt(g._f) : Gn(l), fe = l.type === Bt.BLUR || l.type === Bt.FOCUS_OUT, Mr = !ls(g._f) && !t.resolver && !k(r.errors, d) && !g._f.deps || ds(fe, k(r.touchedFields, d), r.isSubmitted, N, S), st = Kt(d, i, fe);
+      D(s, d, ve), fe ? (!u || !u.readOnly) && (g._f.onBlur && g._f.onBlur(l), f && f(0)) : g._f.onChange && g._f.onChange(l);
+      const at = be(d, ve, fe), Lr = !W(at) || st;
+      if (!fe && y.state.next({
+        name: d,
+        type: l.type,
+        values: U(s)
+      }), Mr)
+        return (v.isValid || h.isValid) && (t.mode === "onBlur" ? fe && E() : fe || E()), Lr && y.state.next({ name: d, ...st ? {} : at });
+      if (!fe && st && y.state.next({ ...r }), t.resolver) {
+        const { errors: It } = await oe([d]);
+        if (x([d]), m(ve), w) {
+          const Nr = Gt(r.errors, n, d), At = Gt(It, n, Nr.name || d);
+          T = At.error, d = At.name, K = W(It);
+        }
+      } else
+        x([d], !0), T = (await Jt(g, i.disabled, s, b, t.shouldUseNativeValidation))[d], x([d]), m(ve), w && (T ? K = !1 : (v.isValid || h.isValid) && (K = await z(n, !0)));
+      w && (g._f.deps && (!Array.isArray(g._f.deps) || g._f.deps.length > 0) && Le(g._f.deps), Ce(d, K, T, at));
+    }
+  }, Me = (l, u) => {
+    if (k(r.errors, u) && l.focus)
+      return l.focus(), 1;
+  }, Le = async (l, u = {}) => {
+    let d, w;
+    const g = Pe(l);
+    if (t.resolver) {
+      const m = await de(B(l) ? l : g);
+      d = W(m), w = l ? !g.some((S) => k(m, S)) : d;
+    } else
+      l ? (w = (await Promise.all(g.map(async (m) => {
+        const S = k(n, m);
+        return await z(S && S._f ? { [m]: S } : S);
+      }))).every(Boolean), !(!w && !r.isValid) && E()) : w = d = await z(n);
+    return y.state.next({
+      ...!Z(l) || (v.isValid || h.isValid) && d !== r.isValid ? {} : { name: l },
+      ...t.resolver || !l ? { isValid: d } : {},
+      errors: r.errors
+    }), u.shouldFocus && !w && $e(n, Me, l ? g : i.mount), w;
+  }, xt = (l, u) => {
+    let d = {
+      ...o.mount ? s : a
+    };
+    return u && (d = yr(u.dirtyFields ? r.dirtyFields : r.touchedFields, d)), B(l) ? d : Z(l) ? k(d, l) : l.map((w) => k(d, w));
+  }, wt = (l, u) => ({
+    invalid: !!k((u || r).errors, l),
+    isDirty: !!k((u || r).dirtyFields, l),
+    error: k((u || r).errors, l),
+    isValidating: !!k(r.validatingFields, l),
+    isTouched: !!k((u || r).touchedFields, l)
+  }), Cr = (l) => {
+    const u = l ? Pe(l) : void 0;
+    u == null || u.forEach((d) => P(r.errors, d)), u ? u.forEach((d) => {
+      y.state.next({
+        name: d,
+        errors: r.errors
+      });
+    }) : y.state.next({
+      errors: {}
+    });
+  }, kt = (l, u, d) => {
+    const w = (k(n, l, { _f: {} })._f || {}).ref, g = k(r.errors, l) || {}, { ref: m, message: S, type: N, ...T } = g;
+    D(r.errors, l, {
+      ...T,
+      ...u,
+      ref: w
+    }), y.state.next({
+      name: l,
+      errors: r.errors,
+      isValid: !1
+    }), d && d.shouldFocus && w && w.focus && w.focus();
+  }, Sr = (l, u) => te(l) ? y.state.subscribe({
+    next: (d) => "values" in d && l(L(void 0, u), d)
+  }) : L(l, u, !0), _t = (l) => y.state.subscribe({
+    next: (u) => {
+      us(l.name, u.name, l.exact) && cs(u, l.formState || v, Ar, l.reRenderRoot) && l.callback({
+        values: { ...s },
+        ...r,
+        ...u,
+        defaultValues: a
+      });
+    }
+  }).unsubscribe, Er = (l) => (o.mount = !0, h = {
+    ...h,
+    ...l.formState
+  }, _t({
+    ...l,
+    formState: {
+      ...C,
+      ...l.formState
+    }
+  })), tt = (l, u = {}) => {
+    for (const d of l ? Pe(l) : i.mount)
+      i.mount.delete(d), i.array.delete(d), u.keepValue || (P(n, d), P(s, d)), !u.keepError && P(r.errors, d), !u.keepDirty && P(r.dirtyFields, d), !u.keepTouched && P(r.touchedFields, d), !u.keepIsValidating && P(r.validatingFields, d), !t.shouldUnregister && !u.keepDefaultValue && P(a, d);
+    y.state.next({
+      values: U(s)
+    }), y.state.next({
+      ...r,
+      ...u.keepDirty ? { isDirty: F() } : {}
+    }), !u.keepIsValid && E();
+  }, Ct = ({ disabled: l, name: u }) => {
+    if (ne(l) && o.mount || l || i.disabled.has(u)) {
+      const g = i.disabled.has(u) !== !!l;
+      l ? i.disabled.add(u) : i.disabled.delete(u), g && o.mount && !o.action && E();
+    }
+  }, rt = (l, u = {}) => {
+    let d = k(n, l);
+    const w = ne(u.disabled) || ne(t.disabled);
+    return D(n, l, {
+      ...d || {},
+      _f: {
+        ...d && d._f ? d._f : { ref: { name: l } },
+        name: l,
+        mount: !0,
+        ...u
+      }
+    }), i.mount.add(l), d ? Ct({
+      disabled: ne(u.disabled) ? u.disabled : t.disabled,
+      name: l
+    }) : M(l, !0, u.value), {
+      ...w ? { disabled: u.disabled || t.disabled } : {},
+      ...t.progressive ? {
+        required: !!u.required,
+        min: Ne(u.min),
+        max: Ne(u.max),
+        minLength: Ne(u.minLength),
+        maxLength: Ne(u.maxLength),
+        pattern: Ne(u.pattern)
+      } : {},
+      name: l,
+      onChange: Ae,
+      onBlur: Ae,
+      ref: (g) => {
+        if (g) {
+          rt(l, u), d = k(n, l);
+          const m = B(g.value) && g.querySelectorAll && g.querySelectorAll("input,select,textarea")[0] || g, S = rs(m), N = d._f.refs || [];
+          if (S ? N.find((T) => T === m) : m === d._f.ref)
+            return;
+          D(n, l, {
+            _f: {
+              ...d._f,
+              ...S ? {
+                refs: [
+                  ...N.filter(ot),
+                  m,
+                  ...Array.isArray(k(a, l)) ? [{}] : []
+                ],
+                ref: { type: m.type, name: l }
+              } : { ref: m }
+            }
+          }), M(l, !1, void 0, m);
+        } else
+          d = k(n, l, {}), d._f && (d._f.mount = !1), (t.shouldUnregister || u.shouldUnregister) && !(Jn(i.array, l) && o.action) && i.unMount.add(l);
+      }
+    };
+  }, nt = () => t.shouldFocusError && $e(n, Me, i.mount), Vr = (l) => {
+    ne(l) && (y.state.next({ disabled: l }), $e(n, (u, d) => {
+      const w = k(n, d);
+      w && (u.disabled = w._f.disabled || l, Array.isArray(w._f.refs) && w._f.refs.forEach((g) => {
+        g.disabled = w._f.disabled || l;
+      }));
+    }, 0, !1));
+  }, St = (l, u) => async (d) => {
+    let w;
+    d && (d.preventDefault && d.preventDefault(), d.persist && d.persist());
+    let g = U(s);
+    if (y.state.next({
+      isSubmitting: !0
+    }), t.resolver) {
+      const { errors: m, values: S } = await oe();
+      x(), r.errors = m, g = U(S);
+    } else
+      await z(n);
+    if (i.disabled.size)
+      for (const m of i.disabled)
+        P(g, m);
+    if (P(r.errors, "root"), W(r.errors)) {
+      y.state.next({
+        errors: {}
+      });
+      try {
+        await l(g, d);
+      } catch (m) {
+        w = m;
+      }
+    } else
+      u && await u({ ...r.errors }, d), nt(), setTimeout(nt);
+    if (y.state.next({
+      isSubmitted: !0,
+      isSubmitting: !1,
+      isSubmitSuccessful: W(r.errors) && !w,
+      submitCount: r.submitCount + 1,
+      errors: r.errors
+    }), w)
+      throw w;
+  }, Fr = (l, u = {}) => {
+    k(n, l) && (B(u.defaultValue) ? X(l, U(k(a, l))) : (X(l, u.defaultValue), D(a, l, U(u.defaultValue))), u.keepTouched || P(r.touchedFields, l), u.keepDirty || (P(r.dirtyFields, l), r.isDirty = u.defaultValue ? F(l, U(k(a, l))) : F()), u.keepError || (P(r.errors, l), v.isValid && E()), y.state.next({ ...r }));
+  }, Et = (l, u = {}) => {
+    const d = l ? U(l) : a, w = U(d), g = W(l), m = g ? a : w;
+    if (u.keepDefaultValues || (a = d), !u.keepValues) {
+      if (u.keepDirtyValues) {
+        const S = /* @__PURE__ */ new Set([
+          ...i.mount,
+          ...Object.keys(Ve(a, s))
+        ]);
+        for (const N of Array.from(S)) {
+          const T = k(r.dirtyFields, N), K = k(s, N), ve = k(m, N);
+          T && !B(K) ? D(m, N, K) : !T && !B(ve) && X(N, ve);
+        }
+      } else {
+        if (mt && B(l))
+          for (const S of i.mount) {
+            const N = k(n, S);
+            if (N && N._f) {
+              const T = Array.isArray(N._f.refs) ? N._f.refs[0] : N._f.ref;
+              if (We(T)) {
+                const K = T.closest("form");
+                if (K) {
+                  K.reset();
+                  break;
+                }
+              }
+            }
+          }
+        if (u.keepFieldsRef)
+          for (const S of i.mount)
+            X(S, k(m, S));
+        else
+          n = {};
+      }
+      s = t.shouldUnregister ? u.keepDefaultValues ? U(a) : {} : U(m), y.array.next({
+        values: { ...m }
+      }), y.state.next({
+        values: { ...m }
+      });
+    }
+    i = {
+      mount: u.keepDirtyValues ? i.mount : /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      disabled: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: !1,
+      focus: ""
+    }, o.mount = !v.isValid || !!u.keepIsValid || !!u.keepDirtyValues || !t.shouldUnregister && !W(m), o.watch = !!t.shouldUnregister, o.keepIsValid = !!u.keepIsValid, o.action = !1, u.keepErrors || (r.errors = {}), y.state.next({
+      submitCount: u.keepSubmitCount ? r.submitCount : 0,
+      isDirty: g ? !1 : u.keepDirty ? r.isDirty : !!(u.keepDefaultValues && !he(l, a)),
+      isSubmitted: u.keepIsSubmitted ? r.isSubmitted : !1,
+      dirtyFields: g ? {} : u.keepDirtyValues ? u.keepDefaultValues && s ? Ve(a, s) : r.dirtyFields : u.keepDefaultValues && l ? Ve(a, l) : u.keepDirty ? r.dirtyFields : {},
+      touchedFields: u.keepTouched ? r.touchedFields : {},
+      errors: u.keepErrors ? r.errors : {},
+      isSubmitSuccessful: u.keepIsSubmitSuccessful ? r.isSubmitSuccessful : !1,
+      isSubmitting: !1,
+      defaultValues: a
+    });
+  }, Vt = (l, u) => Et(te(l) ? l(s) : l, { ...t.resetOptions, ...u }), Ir = (l, u = {}) => {
+    const d = k(n, l), w = d && d._f;
+    if (w) {
+      const g = w.refs ? w.refs[0] : w.ref;
+      g.focus && setTimeout(() => {
+        g.focus(), u.shouldSelect && te(g.select) && g.select();
+      });
+    }
+  }, Ar = (l) => {
+    r = {
+      ...r,
+      ...l
+    };
+  }, Ft = {
+    control: {
+      register: rt,
+      unregister: tt,
+      getFieldState: wt,
+      handleSubmit: St,
+      setError: kt,
+      _subscribe: _t,
+      _runSchema: oe,
+      _updateIsValidating: x,
+      _focusError: nt,
+      _getWatch: L,
+      _getDirty: F,
+      _setValid: E,
+      _setFieldArray: _,
+      _setDisabledField: Ct,
+      _setErrors: O,
+      _getFieldArray: j,
+      _reset: Et,
+      _resetDefaultValues: () => te(t.defaultValues) && t.defaultValues().then((l) => {
+        Vt(l, t.resetOptions), y.state.next({
+          isLoading: !1
+        });
+      }),
+      _removeUnmounted: qe,
+      _disableForm: Vr,
+      _subjects: y,
+      _proxyFormState: v,
+      get _fields() {
+        return n;
+      },
+      get _formValues() {
+        return s;
+      },
+      get _state() {
+        return o;
+      },
+      set _state(l) {
+        o = l;
+      },
+      get _defaultValues() {
+        return a;
+      },
+      get _names() {
+        return i;
+      },
+      set _names(l) {
+        i = l;
+      },
+      get _formState() {
+        return r;
+      },
+      get _options() {
+        return t;
+      },
+      set _options(l) {
+        t = {
+          ...t,
+          ...l
+        };
+      }
+    },
+    subscribe: Er,
+    trigger: Le,
+    register: rt,
+    handleSubmit: St,
+    watch: Sr,
+    setValue: X,
+    getValues: xt,
+    reset: Vt,
+    resetField: Fr,
+    clearErrors: Cr,
+    unregister: tt,
+    setError: kt,
+    setFocus: Ir,
+    getFieldState: wt
+  };
+  return {
+    ...Ft,
+    formControl: Ft
+  };
+}
+function Qe(e = {}) {
+  const t = G.useRef(void 0), r = G.useRef(void 0), [n, a] = G.useState({
+    isDirty: !1,
+    isValidating: !1,
+    isLoading: te(e.defaultValues),
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    validatingFields: {},
+    errors: e.errors || {},
+    disabled: e.disabled || !1,
+    isReady: !1,
+    defaultValues: te(e.defaultValues) ? void 0 : e.defaultValues
+  });
+  if (!t.current)
+    if (e.formControl)
+      t.current = {
+        ...e.formControl,
+        formState: n
+      }, e.defaultValues && !te(e.defaultValues) && e.formControl.reset(e.defaultValues, e.resetOptions);
+    else {
+      const { formControl: o, ...i } = ms(e);
+      t.current = {
+        ...i,
+        formState: n
+      };
+    }
+  const s = t.current.control;
+  return s._options = e, Qn(() => {
+    const o = s._subscribe({
+      formState: s._proxyFormState,
+      callback: () => a({ ...s._formState }),
+      reRenderRoot: !0
+    });
+    return a((i) => ({
+      ...i,
+      isReady: !0
+    })), s._formState.isReady = !0, o;
+  }, [s]), G.useEffect(() => s._disableForm(e.disabled), [s, e.disabled]), G.useEffect(() => {
+    e.mode && (s._options.mode = e.mode), e.reValidateMode && (s._options.reValidateMode = e.reValidateMode);
+  }, [s, e.mode, e.reValidateMode]), G.useEffect(() => {
+    e.errors && (s._setErrors(e.errors), s._focusError());
+  }, [s, e.errors]), G.useEffect(() => {
+    e.shouldUnregister && s._subjects.state.next({
+      values: s._getWatch()
+    });
+  }, [s, e.shouldUnregister]), G.useEffect(() => {
+    if (s._proxyFormState.isDirty) {
+      const o = s._getDirty();
+      o !== n.isDirty && s._subjects.state.next({
+        isDirty: o
+      });
+    }
+  }, [s, n.isDirty]), G.useEffect(() => {
+    var o;
+    e.values && !he(e.values, r.current) ? (s._reset(e.values, {
+      keepFieldsRef: !0,
+      ...s._options.resetOptions
+    }), !((o = s._options.resetOptions) === null || o === void 0) && o.keepIsValid || s._setValid(), r.current = e.values, a((i) => ({ ...i }))) : s._resetDefaultValues();
+  }, [s, e.values]), G.useEffect(() => {
+    s._state.mount || (s._setValid(), s._state.mount = !0), s._state.watch && (s._state.watch = !1, s._subjects.state.next({ ...s._formState })), s._removeUnmounted();
+  }), t.current.formState = G.useMemo(() => Yn(n, s), [s, n]), t.current;
+}
+const Xt = (e, t, r) => {
+  if (e && "reportValidity" in e) {
+    const n = k(r, t);
+    e.setCustomValidity(n && n.message || ""), e.reportValidity();
+  }
+}, gs = (e, t) => {
+  for (const r in t.fields) {
+    const n = t.fields[r];
+    n && n.ref && "reportValidity" in n.ref ? Xt(n.ref, r, e) : n.refs && n.refs.forEach((a) => Xt(a, r, e));
+  }
+}, ys = (e, t) => {
+  t.shouldUseNativeValidation && gs(e, t);
+  const r = {};
+  for (const n in e) {
+    const a = k(t.fields, n), s = Object.assign(e[n] || {}, { ref: a && a.ref });
+    if (bs(t.names || Object.keys(e), n)) {
+      const o = Object.assign({}, k(r, n));
+      D(o, "root", s), D(r, n, o);
+    } else
+      D(r, n, s);
+  }
+  return r;
+}, bs = (e, t) => e.some((r) => r.startsWith(t + "."));
+var et = function(e, t, r) {
+  return r === void 0 && (r = {}), function(n, a, s) {
+    try {
+      var o = !s.shouldUseNativeValidation && s.criteriaMode === "all";
+      return Promise.resolve(jr(e, n, Object.assign({}, t, { abortPipeEarly: !o }))).then(function(i) {
+        if (i.issues) {
+          for (var f = {}; i.issues.length; ) {
+            var p = i.issues[0], C = Ur(p);
+            if (C && (f[C] || (f[C] = { message: p.message, type: p.type }), o)) {
+              var v = f[C].types, h = v && v[p.type];
+              f[C] = gr(C, o, f, p.type, h ? [].concat(h, p.message) : p.message);
+            }
+            i.issues.shift();
+          }
+          return { values: {}, errors: ys(f, s) };
+        }
+        return { values: r.raw ? n : i.output, errors: {} };
+      });
+    } catch (i) {
+      return Promise.reject(i);
+    }
+  };
+};
+const Zt = 27, Yt = 12, Qt = 10, vs = Fe("enum"), xs = (e, t) => {
+  const r = {
+    min: e.minSelected ?? 0,
+    max: e.maxSelected ?? e.options.length
+  };
+  return et(ge({
+    checked: pe(zr(Q(), qr()), ar((n) => Object.entries(n).filter(([a, s]) => s).map(([a, s]) => a)), He(r.max, t("validation_multiple_choice_max", {
+      count: r.max
+    })), Be(r.min, t("validation_multiple_choice_min", {
+      count: r.min
+    })))
+  }));
+}, ws = sr(({
+  option: e,
+  ...t
+}, r) => c(we, {
+  children: [c("input", {
+    class: "peer sr-only h-full",
+    type: "checkbox",
+    ...t,
+    ref: r
+  }), c("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
+  })]
+})), er = Xe("gutter-stable flex w-full flex-1 flex-wrap gap-2 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
+    }
+  }
+}), ks = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  var C, v;
+  const r = e.key ? (C = A.current$.value.flow) == null ? void 0 : C.data.submissions[e.key] : void 0, n = (e.config.minSelected === 1 || e.config.minSelected === void 0) && e.config.maxSelected === 1, a = n && e.config.options.length === 2, {
+    t: s
+  } = Y(), {
+    register: o,
+    handleSubmit: i,
+    formState: {
+      errors: f
+    }
+  } = Qe({
+    defaultValues: {
+      checked: n ? {} : vs(r) ? Object.fromEntries(r.value.map((h) => [h, !0])) : {}
+    },
+    resolver: xs(e.config, s)
+  }), p = pt();
+  return a ? c("ul", {
+    style: {
+      maxHeight: 6.5 * Zt + 5 * Yt + 2 * Qt
+    },
+    class: er({
+      variant: "booleanLike"
+    }),
+    children: e.config.options.map((h, y) => c("li", {
+      class: fr,
+      children: c(hr, {
+        type: "submit",
+        ref: (b) => {
+          b && y === 0 && (p.current = b);
+        },
+        label: h.label,
+        value: "true",
+        onClick: () => t({
+          type: "enum",
+          value: [h.value]
+        })
+      })
+    }, h.value))
+  }) : c("form", {
+    noValidate: !0,
+    onSubmit: (h) => i((y) => {
+      const b = y.checked;
+      t({
+        type: "enum",
+        value: b
+      });
+    })(h),
+    children: [c("div", {
+      class: "flex items-center gap-1",
+      children: [c("ul", {
+        style: {
+          maxHeight: 6.5 * Zt + 5 * Yt + 2 * Qt
+        },
+        class: er({
+          variant: e.config.options.length === 1 ? "singleOption" : void 0
+        }),
+        children: e.config.options.map((h, y) => {
+          const b = `checked.${h.value}`, {
+            ref: V,
+            ...E
+          } = o(b);
+          return c("li", {
+            class: "relative",
+            children: c(ws, {
+              option: h,
+              autoFocus: y === 0,
+              ref: (x) => {
+                x && y === 0 && (p.current = x), V(x);
+              },
+              id: b,
+              ...E,
+              onClick: n ? () => t({
+                type: "enum",
+                value: [h.value]
+              }) : void 0
+            })
+          }, h.value);
+        })
+      }), c("div", {
+        class: "flex flex-col items-center gap-2 pr-2.5 pt-2.5",
+        children: [n ? null : c(ke, {}), e.config.minSelected === 0 && c(_e, {
+          class: "relative",
+          type: "button",
+          onClick: () => t({
+            type: "enum",
+            value: []
+          })
+        })]
+      })]
+    }), c("div", {
+      class: "px-1",
+      children: c(Ie, {
+        error: (v = f.checked) == null ? void 0 : v.root
+      })
+    })]
+  });
+}, _s = Fe("number"), Cs = (e, t) => {
+  const r = e.min ?? Number.MIN_SAFE_INTEGER, n = e.max ?? Number.MAX_SAFE_INTEGER, a = e.decimalCases ?? 0;
+  return et(ge({
+    number: pe(Wr(t("validation_number")), Gr(r, t("validation_number_min", {
+      min: r
+    })), Kr(n, t("validation_number_max", {
+      max: n
+    })), Hr((s) => s === Number(s.toFixed(a)), t("validation_number_decimal_cases", {
+      count: a
+    })))
+  }));
+}, Ss = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  var v;
+  const r = e.config.defaultValue, n = e.key ? (v = A.current$.value.flow) == null ? void 0 : v.data.submissions[e.key] : void 0, {
+    t: a
+  } = Y(), {
+    register: s,
+    handleSubmit: o,
+    formState: {
+      errors: i
+    }
+  } = Qe({
+    defaultValues: {
+      number: r ? Number(r) : _s(n) ? n.value : void 0
+    },
+    resolver: Cs(e.config, a)
+  }), {
+    ref: f,
+    ...p
+  } = s("number", {
+    required: !e.config.optional,
+    valueAsNumber: !0
+  }), C = ae();
+  return ye(() => {
+    C.current && (C.current.focus(), C.current.select());
+  }, []), c("form", {
+    class: "flex flex-col gap-1 p-2.5",
+    onSubmit: o((h) => {
+      h.number !== void 0 && t({
+        type: "number",
+        value: h.number
+      });
+    }),
+    children: [c("div", {
+      class: "flex items-center gap-2",
+      children: [c("div", {
+        class: "relative min-w-0 flex-grow",
+        children: [c("input", {
+          ...p,
+          id: "chat-input",
+          autocomplete: "off",
+          autoCapitalize: "off",
+          autoCorrect: "off",
+          autoFocus: !0,
+          ref: (h) => {
+            h && (C.current = h), f(h);
+          },
+          type: "text",
+          min: e.config.min,
+          max: e.config.max,
+          class: Ue({
+            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 && c(_e, {
+          class: "absolute bottom-0 right-0.5 top-0",
+          onClick: () => t(null)
+        })]
+      }), c(ke, {})]
+    }), c(Ie, {
+      error: i.number
+    })]
+  });
+}, Es = (e) => {
+  if (e === "")
+    return {
+      countryCode: "",
+      phoneNumber: ""
+    };
+  const t = Object.entries(ht).find((a) => e.startsWith(a[1])), r = t ? t[1] : "", n = e.replace(r, "");
+  return /^\d+$/.test(n) ? {
+    countryCode: r,
+    phoneNumber: n
+  } : {
+    countryCode: "",
+    phoneNumber: ""
+  };
+}, Vs = "44", Fs = /^[0-9 ]+$/, Is = Fe("string"), As = Fe("phone"), Ms = (e) => {
+  const t = pe(Q(e("validation_country_code")), ir(Fs, e("validation_country_code"))), r = pe(Q(e("validation_phone")), Be(1, e("validation_phone")), ar((n) => n.replace(/[^0-9]/g, "")));
+  return et(ge({
+    countryCode: t,
+    phoneNumber: r
+  }));
+}, Ls = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  var V;
+  const r = e.key ? (V = A.current$.value.flow) == null ? void 0 : V.data.submissions[e.key] : void 0, {
+    t: n
+  } = Y(), [a, s] = se(), o = Is(r) ? Es(r.value) : As(r) ? r.value : void 0, {
+    register: i,
+    handleSubmit: f,
+    formState: {
+      errors: p
+    },
+    watch: C
+  } = Qe({
+    defaultValues: {
+      countryCode: (o == null ? void 0 : o.countryCode) ?? e.config.defaultValue.countryCode ?? Vs,
+      phoneNumber: (o == null ? void 0 : o.phoneNumber) ?? e.config.defaultValue.phoneNumber ?? ""
+    },
+    resolver: Ms(n)
+  }), {
+    ref: v,
+    ...h
+  } = i("phoneNumber", {
+    required: !e.config.optional
+  }), y = ae(), b = C("countryCode");
+  return ye(() => {
+    y.current && (y.current.focus(), y.current.select());
+  }, []), c("form", {
+    noValidate: !0,
+    class: "flex flex-col gap-1 p-2.5",
+    onSubmit: f((E) => {
+      const x = E.phoneNumber.replace(/[^0-9]/g, ""), _ = E.countryCode.replace(/[^0-9]/g, "");
+      s(void 0);
+      const I = e.config.minChars ?? 7, O = x.length + _.length;
+      if (O < I)
+        return s(n("validation_phone_min_chars", {
+          count: I
+        }));
+      const M = e.config.maxChars;
+      if (M != null && O > M)
+        return s(n("validation_max_chars", {
+          count: M
+        }));
+      e.config.submissionFormat === "phone" ? t({
+        type: "phone",
+        value: {
+          countryCode: _,
+          phoneNumber: x
+        }
+      }) : t({
+        type: "string",
+        value: b + E.phoneNumber
+      });
+    }),
+    children: [c("div", {
+      class: "flex items-center gap-2",
+      children: [c("div", {
+        class: "relative flex min-w-0 flex-1 flex-grow gap-2",
+        children: [c("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: [c("span", {
+            children: ["+", b]
+          }), c("select", {
+            ...i("countryCode", {}),
+            id: `isdk_phone_${e.key}`,
+            class: "absolute inset-0 opacity-0",
+            children: Object.entries(ht).map(([E, x]) => c("option", {
+              value: x,
+              children: [E, " (+", x, ")"]
+            }, E))
+          })]
+        }), c("input", {
+          ...h,
+          id: "chat-input",
+          type: "tel",
+          inputMode: "tel",
+          autocomplete: "off",
+          autoCapitalize: "off",
+          autoCorrect: "off",
+          autoFocus: !0,
+          ref: (E) => {
+            E && (y.current = E), v(E);
+          },
+          class: Ue({
+            optional: e.config.optional,
+            className: "min-w-0 flex-1 rounded-r-full"
+          }),
+          placeholder: e.config.placeholder
+        }), e.config.optional && c(_e, {
+          class: "absolute bottom-0 right-1 top-0",
+          onClick: () => t(null)
+        })]
+      }), c(ke, {})]
+    }), c(Ie, {
+      error: p.countryCode || p.phoneNumber || {
+        message: a
+      }
+    })]
+  });
+}, Ns = ({
+  input: e,
+  onSubmitSuccess: t
+}) => c("div", {
+  class: "flex flex-col items-center py-3",
+  children: c("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: c("span", {
+      class: "flex items-center gap-1.5",
+      children: [c("span", {
+        class: "inline-flex items-center text-sm font-medium",
+        children: e.config.label || "Submit"
+      }), c("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: [c("path", {
+          d: "M4 8L8 4L12 8"
+        }), c("path", {
+          d: "M8 4V13"
+        })]
+      })]
+    })
+  })
+}), Ts = {
+  date: {
+    type: "date",
+    inputMode: "text"
+  },
+  email: {
+    type: "email",
+    inputMode: "email",
+    formNoValidate: !0
+  },
+  text: {
+    type: "text",
+    inputMode: "text"
+  },
+  url: {
+    type: "url",
+    inputMode: "url",
+    formNoValidate: !0
+  }
+}, Ds = Fe("string"), Rs = (e, t) => {
+  const r = {
+    maxLength: t("validation_max_chars", {
+      count: e.maxChars ?? 999
+    }),
+    minLength: t("validation_min_chars", {
+      count: e.minChars ?? 1
+    })
+  };
+  return et(ge({
+    text: {
+      date: pe(Q(t("validation_date")), ir(/^\d{4}-\d{2}-\d{2}$/, t("validation_date"))),
+      email: pe(Q(t("validation_email")), Jr(t("validation_email")), Be(e.minChars ?? 1, r.minLength), He(e.maxChars ?? 1 / 0, r.maxLength)),
+      text: pe(Q(), Be(e.minChars ?? 1, r.minLength), He(e.maxChars ?? 1 / 0, r.maxLength)),
+      url: pe(Q(t("validation_url")), Xr(t("validation_url")), Be(e.minChars ?? 1, r.minLength), He(e.maxChars ?? 1 / 0, r.maxLength))
+    }[e.format]
+  }));
+}, Os = ({
+  input: e,
+  onSubmitSuccess: t
+}) => {
+  var v;
+  const {
+    t: r
+  } = Y(), n = e.key ? (v = A.current$.value.flow) == null ? void 0 : v.data.submissions[e.key] : void 0, a = e.config.defaultValue, {
+    register: s,
+    handleSubmit: o,
+    formState: {
+      errors: i
+    }
+  } = Qe({
+    defaultValues: {
+      text: a || (Ds(n) ? n.value : "")
+    },
+    resolver: Rs(e.config, r)
+  }), {
+    ref: f,
+    ...p
+  } = s("text", {
+    required: !e.config.optional
+  }), C = ae();
+  return ye(() => {
+    C.current && (C.current.focus(), C.current.select());
+  }, []), c("form", {
+    noValidate: !0,
+    class: "flex flex-col gap-1 p-2.5",
+    onSubmit: o((h) => {
+      t({
+        type: "string",
+        value: h.text
+      });
+    }),
+    children: [c("div", {
+      class: "flex items-center gap-2",
+      children: [c("div", {
+        class: "relative min-w-0 flex-1",
+        children: [c("input", {
+          id: "chat-input",
+          ...p,
+          ...Ts[e.config.format],
+          autocomplete: "off",
+          autoCapitalize: "off",
+          autoCorrect: "off",
+          autoFocus: !0,
+          ref: (h) => {
+            h && (C.current = h), f(h);
+          },
+          placeholder: e.config.placeholder,
+          class: Ue({
+            optional: !!e.config.optional,
+            className: "w-full rounded-full"
+          })
+        }), e.config.optional && c(_e, {
+          class: "absolute bottom-0 right-0.5 top-0",
+          onClick: () => t(null)
+        })]
+      }), c(ke, {})]
+    }), c(Ie, {
+      error: i.text
+    })]
+  });
+}, Bs = {
+  text: Os,
+  phone: Ls,
+  "multiple-choice": ks,
+  boolean: Pn,
+  file: Kn,
+  submit: Ns,
+  address: Dn,
+  number: Ss
+}, Ps = ({
+  logger: e
+}) => {
+  var s;
+  const t = (s = A.current$.value.flow) == null ? void 0 : s.data.currentInput, [r, n] = _n(), a = ae(null);
+  return A.inputHeight$.value = n.height, ue(() => {
+    const o = a.current;
+    if (o)
+      return o.addEventListener("transitionstart", H.scrollToEnd.smooth), o.addEventListener("transitioncancel", H.scrollToEnd.smooth), o.addEventListener("transitionend", H.scrollToEnd.smooth), () => {
+        o.removeEventListener("transitionstart", H.scrollToEnd.smooth), o.removeEventListener("transitioncancel", H.scrollToEnd.smooth), o.removeEventListener("transitionend", H.scrollToEnd.smooth);
+      };
+  }, []), c("div", {
+    ref: a,
+    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: c("div", {
+      ref: r,
+      class: "border-divider flex flex-col justify-end border-t",
+      children: t ? (() => {
+        const o = Bs[t.type];
+        return c(o, {
+          logger: e,
+          onSubmitSuccess: H.onSubmitSuccessFn$.value,
+          input: t
+        });
+      })() : c("div", {
+        class: "flex items-center gap-2 p-2.5",
+        children: [c("input", {
+          "aria-hidden": "true",
+          id: "chat-input",
+          class: Ue({
+            optional: !1,
+            className: "flex-grow rounded-full"
+          }),
+          disabled: !0
+        }), c(ke, {
+          disabled: !0,
+          "aria-hidden": "true",
+          tabIndex: -1
+        })]
+      })
+    })
+  });
+};
+var $s = function(e) {
+  return e instanceof RegExp;
+}, js = 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";
+}, Us = function(e) {
+  var t = [];
+  return e.forEach(function(r) {
+    Array.isArray(r) ? t = t.concat(r) : t.push(r);
+  }), t;
+};
+function zs(e, t, r) {
+  var n = 0, a = 0;
+  if (e === "")
+    return e;
+  if (!e || !_r(e))
+    throw new TypeError("First argument to react-string-replace#replaceString must be a string");
+  var s = t;
+  $s(s) || (s = new RegExp("(" + js(s) + ")", "gi"));
+  for (var o = e.split(s), i = 1, f = o.length; i < f; i += 2) {
+    if (o[i] === void 0 || o[i - 1] === void 0) {
+      console.warn("reactStringReplace: Encountered undefined value during string replacement. Your RegExp may not be working the way you expect.");
+      continue;
+    }
+    a = o[i].length, n += o[i - 1].length, o[i] = r(o[i], i, n), n += a;
+  }
+  return o;
+}
+var qs = function(t, r, n) {
+  return Array.isArray(t) || (t = [t]), Us(t.map(function(a) {
+    return _r(a) ? zs(a, r, n) : a;
+  }));
+};
+const Te = /* @__PURE__ */ Zr(qs), Hs = /(\[[^\]]+\]\([^)]+\))/g, Ks = /\[([^\]]+)\]\(([^)]+)\)/, Gs = /(https?:\/\/[^\s]+)/g, Ws = /_(.*?)_/g, Js = /\*\*(.*?)\*\*/g, Xs = /\\n|\n/g, tr = "text-accent-10 hover:text-accent-11 no-underline underline-offset-2 hover:underline", Zs = (e) => {
+  const t = Te(e, Hs, (o, i) => {
+    const [, f, p] = o.match(Ks) ?? [];
+    return p ? c("a", {
+      class: tr,
+      href: p,
+      children: f ?? p
+    }, p + i) : c("span", {
+      children: "INVALID LINK"
+    });
+  }), r = Te(t, Gs, (o, i) => c("a", {
+    class: tr,
+    href: o,
+    children: o
+  }, o + i)), n = Te(r, Ws, (o, i) => c("em", {
+    children: o
+  }, o + i)), a = Te(n, Js, (o, i) => c("strong", {
+    children: o
+  }, o + i));
+  return Te(a, Xs, (o, i) => c("br", {}, `br-${i}`));
+}, Ys = Xe("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,
+  ...a
+}) => c("p", {
+  style: {
+    transformOrigin: n === "left" ? "0% 50%" : "100% 50%"
+  },
+  class: Ys({
+    className: t,
+    side: n,
+    animate: r
+  }),
+  ...a,
+  children: e
+}), ea = ({
+  message: e
+}) => c("div", {
+  class: "bg-accent-3 flex w-full items-center justify-center overflow-hidden rounded-xl px-2 py-2",
+  children: c("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, c("svg", {
+      class: "flex-none",
+      width: "15",
+      height: "15",
+      viewBox: "0 0 15 15",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: c("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"
+      })
+    })]
+  })
+}), ta = ({
+  className: e,
+  ...t
+}) => (ue(() => {
+  H.scrollToEnd.smooth();
+}), c("div", {
+  "aria-hidden": !0,
+  children: H.isBotTyping$.value === !0 ? c("div", {
+    "aria-label": "Typing…",
+    class: je("flex gap-1 p-4", e),
+    ...t,
+    children: Array.from({
+      length: 3
+    }, (r, n) => c("div", {
+      class: "bg-accent-9 h-1.5 w-1.5 animate-bounce rounded-full",
+      style: {
+        animationDelay: `${-n * 200}ms`
+      }
+    }))
+  }) : void 0
+})), ra = {
+  bot: "left",
+  user: "right"
+}, na = Xe("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]"
+    }
+  }
+}), sa = ({
+  lastSentMessageFooter: e
+}) => {
+  var r;
+  const t = ((r = A.current$.value.flow) == null ? void 0 : r.data.messages) ?? [];
+  return ue(() => {
+    H.scrollToEnd.smooth();
+  }, [t.length]), c("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, a) => c(we, {
+      children: c("li", {
+        class: "flex",
+        children: Ge(n).with({
+          type: "system"
+        }, (s) => c("p", {
+          class: na({
+            variant: s.variant
+          }),
+          children: s.text
+        })).with({
+          type: "text",
+          author: R.union("bot", "user")
+        }, (s) => {
+          const o = s.author === "user" && !t.slice(a + 1).some((p) => p.type === "text" && p.author === "user"), i = a === t.length - 1, f = s.author === "bot" ? Zs(s.text) : s.text;
+          return c(we, {
+            children: [o ? e : null, c(Qs, {
+              animate: i,
+              side: ra[s.author],
+              children: f
+            }, a)]
+          });
+        }).with({
+          type: "link"
+        }, (s) => c(ea, {
+          message: s
+        })).with({
+          type: "image"
+        }, (s) => c("img", {
+          class: "shadow-surface-md w-full max-w-[min(100%,24rem)] rounded-2xl",
+          src: s.url,
+          style: {
+            aspectRatio: s.width / s.height
+          }
+        })).with({
+          type: "file"
+        }, (s) => c(zn, {
+          class: s.author === "bot" ? void 0 : "ml-auto",
+          file: {
+            name: s.fileName,
+            sizeKb: s.fileSizeKb
+          }
+        })).with({
+          type: "loading"
+        }, (s) => {
+          const o = t[t.length - 1];
+          return !(s === o) || H.isBotTyping$.value ? null : c("div", {
+            class: "flex flex-grow flex-col items-center justify-center",
+            children: c(Yr, {
+              class: "text-neutral-6 h-8 w-8"
+            })
+          });
+        }).exhaustive()
+      })
+    }, a)), c(ta, {}, "typing")]
+  });
+}, ua = ({
+  logger: e,
+  apiClient: t,
+  analytics: r,
+  platformClient: n
+}) => {
+  const {
+    flow: a
+  } = A.current$.value;
+  me(a, "Flow is required to exist to show chatbot body");
+  const s = A.viewState$.value, {
+    chatRef: o,
+    chatService: i
+  } = In(), {
+    t: f
+  } = Y(), [p, C] = se();
+  return ye(() => {
+    s === "maximised" && H.scrollToEnd.instant();
+  }, [s]), ye(() => {
+    var x, _;
+    const {
+      state: v,
+      flow: h
+    } = A.current$.peek();
+    if (v !== "loaded")
+      throw new Error(f("invalid_state"));
+    let y = h.data.nodeHistory.at(-1);
+    if (H.scrollToEnd.instant(), A.setInput(void 0), h.data.isFinished)
+      return;
+    y === void 0 ? (y = nr(a.nodes).id, A.setCurrentNodeId(y), r.log({
+      event: "FLOW_START",
+      properties: {
+        flow_id: a.id,
+        flow_version: a.version,
+        flow_session_id: h.data.flowSessionId,
+        flow_build: a.build,
+        job: a.job
+      },
+      customProperties: (x = a.analytics) == null ? void 0 : x.customProperties
+    })) : A.removeMessagesSentByNodeIds([y]);
+    const {
+      interpret: b,
+      abort: V,
+      undo: E
+    } = rn({
+      context: a.context,
+      analytics: {
+        service: r,
+        customProperties: (_ = a.analytics) == null ? void 0 : _.customProperties
+      },
+      apiClient: t,
+      logger: e,
+      platformClient: n,
+      flow: a,
+      chatService: i,
+      t: f,
+      // We need to get fresh submissions, that’s why we call `peek` here.
+      getSubmissions: () => {
+        var I;
+        return (I = A.current$.peek().flow) == null ? void 0 : I.data.submissions;
+      },
+      onInterpret: (I) => A.setCurrentNodeId(I.id),
+      onFlowEnd: async () => {
+        var O;
+        A.markAsFinished();
+        const I = A.current$.peek().flow;
+        me(I), r.log({
+          event: "FLOW_END",
+          properties: {
+            flow_id: a.id,
+            flow_version: a.version,
+            flow_session_id: I.data.flowSessionId,
+            flow_build: a.build,
+            job: a.job
+          },
+          customProperties: (O = a.analytics) == null ? void 0 : O.customProperties
+        });
+      }
+    });
+    return C(() => E), b(y), V;
+  }, [r, t, i, e, a, n, f]), c(we, {
+    children: [c("div", {
+      ref: o,
+      className: "hide-scrollbars relative flex w-full max-w-full flex-grow flex-col overflow-y-scroll",
+      style: {
+        WebkitOverflowScrolling: "touch",
+        paddingBottom: A.inputHeight$.value
+      },
+      children: c(sa, {
+        lastSentMessageFooter: a.data.isFinished || !p ? null : c(ia, {
+          undoFn: p
+        })
+      })
+    }), c(Ps, {
+      logger: e
+    })]
+  });
+}, aa = (e) => e.type === "identify" ? [] : "key" in e.data && e.data.key ? [e.data.key] : "keys" in e.data ? Object.values(e.data.keys).filter((t) => typeof t == "string") : [], ia = ({
+  undoFn: e
+}) => {
+  const {
+    t
+  } = Y();
+  return c(Qr, {
+    onClick: async () => {
+      const {
+        flow: r
+      } = A.current$.peek();
+      me(r);
+      const {
+        removed: n
+      } = e(r.data.nodeHistory), a = r.data.nodeHistory.splice(-n);
+      a.length !== 0 && (A.removeMessagesSentByNodeIds(a), A.setInput(void 0), a.pop(), a.map((s) => r.nodes.find((o) => o.id === s)).filter(Boolean).flatMap(aa).forEach((s) => delete r.data.submissions[s]), A.current$.value = {
+        ...A.current$.value
+      });
+    },
+    children: [c("title", {
+      children: t("undo")
+    }), c("path", {
+      d: "M3 13h2.67l6.66-6.67a1.9 1.9 0 0 0 0-2.66 1.91 1.91 0 0 0-2.66 0L3 10.33V13Zm4.6-7.25 2.67 2.67"
+    })]
+  });
+};
+export {
+  ua as ChatbotBody
+};