@inploi/plugin-chatbot 3.2.4 → 3.2.6

package/dist/job-application-content-bbb02124.cjs

@@ -0,0 +1,2912 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const framerMotion = require("framer-motion");
+const index = require("./index-4a06c2aa.cjs");
+require("@inploi/sdk");
+const followNodes = ({
+  node,
+  nodes,
+  stopWhen
+}) => {
+  if ((stopWhen == null ? void 0 : stopWhen(node)) === true)
+    return node;
+  const nextNode = node.nextId ? nodes.find((n2) => n2.id === node.nextId) : void 0;
+  if (!nextNode)
+    return;
+  return followNodes({
+    node: nextNode,
+    nodes,
+    stopWhen
+  });
+};
+const fallthroughBranch = ({
+  childNode,
+  nodes
+}) => {
+  const branches = nodes.filter((node) => node.type === "if-block");
+  const branch = branches.find((branchNode) => {
+    if (!branchNode.branchId)
+      return false;
+    const nodeToFollow = nodes.find((n2) => n2.id === branchNode.branchId);
+    if (!nodeToFollow)
+      return false;
+    const node = followNodes({
+      node: nodeToFollow,
+      nodes,
+      stopWhen: (n2) => n2.id === childNode.id
+    });
+    if (!node || node.id !== childNode.id)
+      return false;
+    return true;
+  });
+  if (!(branch == null ? void 0 : branch.nextId))
+    return;
+  return nodes.find((n2) => n2.id === branch.nextId);
+};
+const createFlowInterpreter = ({
+  flow,
+  analytics,
+  logger,
+  context,
+  apiClient,
+  getSubmissions,
+  chatService,
+  onFlowEnd,
+  onInterpret
+}) => {
+  const controller = new AbortController();
+  const interpretNode = async (node, prevNode) => {
+    const submissions = getSubmissions();
+    onInterpret == null ? void 0 : onInterpret(node, prevNode);
+    try {
+      await interpret({
+        analytics,
+        logger,
+        apiClient,
+        context,
+        node,
+        submissions,
+        chat: {
+          sendMessage: async (message) => chatService.send({
+            groupId: node.id,
+            message,
+            signal: controller.signal
+          }),
+          userInput: async (input) => chatService.input({
+            input,
+            signal: controller.signal
+          })
+        },
+        next: (nodeId) => {
+          const nextNode = nodeId ? flow.find((node2) => node2.id === nodeId) : fallthroughBranch({
+            childNode: node,
+            nodes: flow
+          });
+          if (!nextNode)
+            return onFlowEnd == null ? void 0 : onFlowEnd(node);
+          return interpretNode(nextNode, node);
+        }
+      });
+    } catch (e) {
+      if (e instanceof index.AbortedError)
+        return;
+      throw e;
+    }
+  };
+  return {
+    interpret: async (startFromNodeId) => {
+      const startNode = flow.find((node) => node.id === startFromNodeId) ?? index.getHeadOrThrow(flow);
+      return interpretNode(startNode);
+    },
+    abort: () => {
+      controller.abort();
+    }
+  };
+};
+async function interpret(params) {
+  return await index.N(params).with({
+    node: {
+      type: "text"
+    }
+  }, interpretTextNode).with({
+    node: {
+      type: "image"
+    }
+  }, interpretImageNode).with({
+    node: {
+      type: "question-text"
+    }
+  }, interpretQuestionTextNode).with({
+    node: {
+      type: "question-enum"
+    }
+  }, interpretQuestionEnumNode).with({
+    node: {
+      type: "question-number"
+    }
+  }, interpretQuestionNumberNode).with({
+    node: {
+      type: "question-boolean"
+    }
+  }, interpretQuestionBooleanNode).with({
+    node: {
+      type: "question-file"
+    }
+  }, interpretQuestionFileNode).with({
+    node: {
+      type: "question-address"
+    }
+  }, interpretQuestionAddressNode).with({
+    node: {
+      type: "end-flow"
+    }
+  }, interpretEndFlowNode).with({
+    node: {
+      type: "if-block"
+    }
+  }, interpretIfBlockNode).with({
+    node: {
+      type: "jump"
+    }
+  }, ({
+    node,
+    next
+  }) => next(node.data.targetId)).with({
+    node: {
+      type: "link"
+    }
+  }, interpretLinkNode).with({
+    node: {
+      type: "submit"
+    }
+  }, interpretSubmitNode).exhaustive();
+}
+async function interpretSubmitNode({
+  chat,
+  next,
+  node,
+  logger,
+  apiClient,
+  submissions,
+  context
+}) {
+  await chat.userInput({
+    type: "multiple-choice",
+    key: void 0,
+    config: {
+      options: [{
+        label: "Submit my application",
+        value: "submit"
+      }],
+      maxSelected: 1,
+      minSelected: 1
+    }
+  });
+  await chat.sendMessage({
+    type: "system",
+    variant: "info",
+    text: "Submitting your application…"
+  });
+  const response = await apiClient.fetch(`/flow/apply`, {
+    method: "POST",
+    body: JSON.stringify({
+      ...context,
+      submissions: index.getApplicationSubmissionsPayload(submissions || {})
+    })
+  }).catch((e) => e);
+  await index.N(response).with({
+    redirect_url: index._.string
+  }, async (response2) => {
+    await chat.sendMessage({
+      type: "text",
+      author: "bot",
+      text: "Almost there! Please finalise your application on our partner’s website."
+    });
+    await chat.sendMessage({
+      type: "link",
+      href: response2.redirect_url,
+      text: "Finalise application on partner"
+    });
+  }).with({
+    message: "Success"
+  }, async () => {
+    await chat.sendMessage({
+      type: "system",
+      variant: "success",
+      text: "Application submitted"
+    });
+    next(node.nextId);
+  }).otherwise(async (response2) => {
+    logger.error(response2);
+    await chat.sendMessage({
+      type: "system",
+      variant: "error",
+      text: "Failed to submit application"
+    });
+    next(node.id);
+  });
+}
+async function interpretLinkNode({
+  chat,
+  next,
+  node
+}) {
+  await chat.sendMessage({
+    type: "link",
+    href: node.data.href,
+    text: node.data.cta
+  });
+  next(node.nextId);
+}
+async function interpretIfBlockNode({
+  submissions,
+  next,
+  node
+}) {
+  const nextId = isIfBlockConditionMet(node, submissions) ? node.branchId : node.nextId;
+  next(nextId);
+}
+async function interpretTextNode({
+  chat,
+  next,
+  node
+}) {
+  await chat.sendMessage({
+    author: "bot",
+    type: "text",
+    text: node.data.text
+  });
+  next(node.nextId);
+}
+async function interpretImageNode({
+  chat,
+  next,
+  node
+}) {
+  await chat.sendMessage({
+    author: "bot",
+    type: "image",
+    url: node.data.url,
+    height: node.data.height,
+    width: node.data.width
+  });
+  next(node.nextId);
+}
+async function interpretQuestionTextNode({
+  chat,
+  next,
+  node
+}) {
+  await chat.sendMessage({
+    author: "bot",
+    type: "text",
+    text: node.data.question
+  });
+  const reply = await chat.userInput({
+    key: node.data.key,
+    type: "text",
+    config: {
+      placeholder: node.data.placeholder,
+      format: node.data.format
+    }
+  });
+  await chat.sendMessage({
+    author: "user",
+    type: "text",
+    text: reply.value
+  });
+  next(node.nextId);
+}
+async function interpretQuestionNumberNode({
+  chat,
+  next,
+  node
+}) {
+  await chat.sendMessage({
+    author: "bot",
+    type: "text",
+    text: node.data.question
+  });
+  const reply = await chat.userInput({
+    key: node.data.key,
+    type: "text",
+    config: {
+      placeholder: node.data.placeholder,
+      format: "text"
+    }
+  });
+  await chat.sendMessage({
+    author: "user",
+    type: "text",
+    text: reply.value
+  });
+  next(node.nextId);
+}
+async function interpretQuestionEnumNode({
+  chat,
+  next,
+  node
+}) {
+  await chat.sendMessage({
+    author: "bot",
+    type: "text",
+    text: node.data.question
+  });
+  const reply = await chat.userInput({
+    key: node.data.key,
+    type: "multiple-choice",
+    config: node.data
+  });
+  await chat.sendMessage({
+    author: "user",
+    type: "text",
+    text: reply.value.join(", ")
+  });
+  next(node.nextId);
+}
+async function interpretQuestionBooleanNode({
+  chat,
+  next,
+  node
+}) {
+  await chat.sendMessage({
+    author: "bot",
+    type: "text",
+    text: node.data.question
+  });
+  const input = await chat.userInput({
+    key: node.data.key,
+    type: "boolean",
+    config: {
+      labels: {
+        true: node.data.trueLabel,
+        false: node.data.falseLabel
+      }
+    }
+  });
+  const reply = input.value;
+  const labelMap = {
+    true: node.data.trueLabel,
+    false: node.data.falseLabel
+  };
+  await chat.sendMessage({
+    author: "user",
+    type: "text",
+    text: labelMap[reply]
+  });
+  next(node.nextId);
+}
+async function interpretQuestionAddressNode({
+  chat,
+  next,
+  node
+}) {
+  await chat.sendMessage({
+    author: "bot",
+    type: "text",
+    text: "Address questions are not implemented yet"
+  });
+  next(node.nextId);
+}
+async function interpretQuestionFileNode({
+  node,
+  chat,
+  next
+}) {
+  await chat.sendMessage({
+    author: "bot",
+    type: "text",
+    text: node.data.question
+  });
+  const files = await chat.userInput({
+    key: node.data.key,
+    type: "file",
+    config: {
+      extensions: node.data.extensions,
+      fileSizeLimitKib: node.data.maxSizeKb,
+      allowMultiple: node.data.multiple === true
+    }
+  });
+  for await (const file of files.value) {
+    await chat.sendMessage({
+      author: "user",
+      type: "file",
+      fileName: file.name,
+      fileSizeKb: file.sizeKb
+    });
+  }
+  next(node.nextId);
+}
+async function interpretEndFlowNode({
+  chat,
+  next,
+  node
+}) {
+  await chat.sendMessage({
+    type: "system",
+    variant: "info",
+    text: node.data.systemMessage || "Conversation finished"
+  });
+  next(void 0);
+}
+const stringOrStringArray = index._.union(index._.string, index._.array(index._.string));
+const isIfBlockConditionMet = (ifBlock, submissions) => {
+  const answer = submissions == null ? void 0 : submissions[ifBlock.data.compareKey];
+  if (!answer)
+    return false;
+  return index.N({
+    ...ifBlock.data,
+    answer
+  }).with({
+    compare: "equals"
+  }, ({
+    compareValue
+  }) => {
+    if (typeof answer.value === "string" || typeof answer.value === "boolean")
+      return compareValue === answer.value.toString();
+    return false;
+  }).with({
+    compare: "notEquals"
+  }, ({
+    compareValue
+  }) => {
+    if (typeof answer.value === "string" || typeof answer.value === "boolean")
+      return compareValue !== answer.value.toString();
+    return false;
+  }).with({
+    compare: "contains",
+    answer: {
+      value: stringOrStringArray
+    }
+  }, ({
+    compareValue,
+    answer: answer2
+  }) => answer2.value.includes(compareValue)).with({
+    compare: "notContains",
+    answer: {
+      value: stringOrStringArray
+    }
+  }, ({
+    compareValue,
+    answer: answer2
+  }) => !answer2.value.includes(compareValue)).with({
+    answer: {
+      type: "file"
+    }
+  }, () => false).exhaustive();
+};
+const SendButton = ({
+  class: className,
+  ...props
+}) => index.o("button", {
+  class: index.clsx("bg-accent-7 active:bg-accent-10 active:text-accent-2 text-lowest pointer-coarse:touch-hitbox focus-visible:ring-accent-7/50 flex-shrink-0 rounded-full p-2 transition-all focus:outline-none focus-visible:ring-4 focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50", className),
+  ...props,
+  children: index.o("svg", {
+    class: "block",
+    width: "16",
+    height: "16",
+    viewBox: "0 0 16 16",
+    fill: "transparent",
+    stroke: "currentColor",
+    "stroke-linecap": "round",
+    "stroke-width": "2",
+    children: [index.o("title", {
+      children: "Send"
+    }), index.o("path", {
+      d: "M3.5 7.5L8 3L12.5 7.5"
+    }), index.o("path", {
+      d: "M8 4V13"
+    })]
+  })
+});
+const useFocusOnMount = () => {
+  const focusRef = index._$1(null);
+  index.p(() => {
+    var _a;
+    (_a = focusRef.current) == null ? void 0 : _a.focus();
+  }, []);
+  return focusRef;
+};
+const options = ["true", "false"];
+const AnswerSchema = index.picklist(options);
+const FIELD_NAME = "answer";
+const ChatInputBoolean = ({
+  input,
+  onSubmitSuccess,
+  onHeightChange
+}) => {
+  const focusRef = useFocusOnMount();
+  onHeightChange();
+  return index.o("form", {
+    noValidate: true,
+    class: "flex items-center gap-2",
+    onSubmit: (e) => {
+      e.preventDefault();
+      const value = index.N(e).with({
+        nativeEvent: {
+          submitter: index._.select(index._.union(index._.instanceOf(HTMLButtonElement), index._.instanceOf(HTMLInputElement)))
+        }
+      }, (submitter) => {
+        return submitter.value;
+      }).otherwise(() => {
+        throw new Error("invalid form");
+      });
+      const answer = index.parse(AnswerSchema, value);
+      onSubmitSuccess(answer);
+    },
+    children: options.map((value, i2) => {
+      return index.o("button", {
+        ref: i2 === 0 ? focusRef : null,
+        type: "submit",
+        name: FIELD_NAME,
+        value,
+        class: "bg-lowest ease-expo-out ring-neutral-12/5 text-neutral-12 active:ring-accent-7 active:bg-accent-2 active:text-accent-11 fr block flex-1 overflow-hidden rounded-2xl px-2.5 py-2.5 ring-2 transition-all duration-300 selection:bg-transparent",
+        children: index.o("p", {
+          class: "truncate text-center text-base",
+          children: input.config.labels[value]
+        })
+      });
+    })
+  });
+};
+const InputError = ({
+  error,
+  onAnimationComplete
+}) => {
+  return index.o(framerMotion.AnimatePresence, {
+    children: error && index.o(framerMotion.m.div, {
+      initial: {
+        height: 0,
+        opacity: 0
+      },
+      animate: {
+        height: "auto",
+        opacity: 1
+      },
+      exit: {
+        height: 0,
+        opacity: 0
+      },
+      onAnimationComplete,
+      role: "alert",
+      class: "text-error-11 flex max-w-full items-center gap-1 overflow-hidden rounded-full p-0.5 px-1 opacity-0",
+      children: [index.o("svg", {
+        class: "text-error-10",
+        width: "16",
+        height: "16",
+        viewBox: "0 0 16 16",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+        children: [index.o("circle", {
+          cx: "8",
+          cy: "8",
+          r: "6.3",
+          stroke: "currentColor",
+          "stroke-width": "1.4"
+        }), index.o("rect", {
+          x: "7",
+          y: "4",
+          width: "2",
+          height: "5",
+          fill: "currentColor"
+        }), index.o("rect", {
+          x: "7",
+          y: "10",
+          width: "2",
+          height: "2",
+          fill: "currentColor"
+        })]
+      }), index.o("p", {
+        class: "truncate pr-1 text-sm",
+        children: error.message
+      })]
+    })
+  });
+};
+const toBase64 = (file) => new Promise((resolve, reject) => {
+  const reader = new FileReader();
+  reader.readAsDataURL(file);
+  reader.onload = () => {
+    if (!reader.result)
+      return reject("No result from reader");
+    return resolve(reader.result.toString());
+  };
+  reader.onerror = reject;
+});
+const kbToReadableSize = (kb) => index.N(kb).with(index._.number.lte(1e3), () => `${Math.round(kb)}KB`).with(index._.number.lt(1e3 * 10), () => `${(kb / 1e3).toFixed(1)}MB`).otherwise(() => `${Math.round(kb / 1e3)}MB`);
+const addFileSizesKb = (files) => files.reduce((acc, cur) => acc + cur.sizeKb, 0);
+const isFileSubmission = index.isSubmissionOfType("file");
+const FILENAMES_TO_SHOW_QTY = 3;
+const FileThumbnail = ({
+  file,
+  class: className,
+  ...props
+}) => {
+  const extension = file.name.split(".").pop();
+  const fileName = file.name.replace(new RegExp(`.${extension}$`), "");
+  return index.o("div", {
+    class: index.clsx("bg-accent-1 outline-neutral-4 flex max-w-full gap-2 overflow-hidden rounded-lg px-3 py-2 text-sm outline", className),
+    ...props,
+    children: [index.o("p", {
+      "aria-label": "File name",
+      class: "text-accent-12 flex flex-grow overflow-hidden",
+      children: [index.o("span", {
+        class: "block truncate",
+        children: fileName
+      }), index.o("span", {
+        children: [".", extension]
+      })]
+    }), index.o("p", {
+      "aria-label": "File size",
+      class: "text-neutral-10",
+      children: kbToReadableSize(file.sizeKb)
+    })]
+  });
+};
+const FilenameBadge = ({
+  class: className,
+  ...props
+}) => index.o("li", {
+  class: index.clsx("outline-neutral-6 text-neutral-11 bg-neutral-1 block rounded-md px-1 py-0.5 text-xs outline outline-1", className),
+  ...props
+});
+const ChatInputFile = ({
+  input,
+  onSubmitSuccess,
+  onHeightChange
+}) => {
+  var _a;
+  const submission = (_a = index.application.current$.value.application) == null ? void 0 : _a.data.submissions[input.key];
+  const [files, setFiles] = index.h(isFileSubmission(submission) ? submission.value : []);
+  const [error, setError] = index.h();
+  const hiddenFileCount = files.length - FILENAMES_TO_SHOW_QTY;
+  const totalSize = addFileSizesKb(files);
+  const focusRef = useFocusOnMount();
+  return index.o("form", {
+    class: "flex flex-col gap-1",
+    onSubmit: (e) => {
+      e.preventDefault();
+      setError(void 0);
+      if (files.length === 0) {
+        setError({
+          type: "required",
+          message: "Please select a file"
+        });
+      }
+      if (input.config.fileSizeLimitKib && totalSize > input.config.fileSizeLimitKib) {
+        setError({
+          type: "max",
+          message: `File size exceeds limit of ${kbToReadableSize(input.config.fileSizeLimitKib)}`
+        });
+      }
+      return onSubmitSuccess(files);
+    },
+    children: [index.o("div", {
+      class: "flex items-center gap-2",
+      children: [index.o("label", {
+        ref: focusRef,
+        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: [files.length > 0 ? index.o(index.k, {
+          children: [index.o("ul", {
+            class: "flex max-w-full flex-wrap justify-center gap-1 overflow-hidden p-1",
+            children: [files.slice(0, FILENAMES_TO_SHOW_QTY).map((file) => {
+              const extension = file.name.split(".").pop();
+              const fileName = file.name.replace(new RegExp(`.${extension}$`), "");
+              return index.o(FilenameBadge, {
+                class: "flex overflow-hidden",
+                children: [index.o("span", {
+                  class: "block truncate",
+                  children: fileName
+                }), index.o("span", {
+                  children: [".", extension]
+                })]
+              });
+            }), hiddenFileCount > 0 ? index.o(FilenameBadge, {
+              children: ["+", hiddenFileCount, " file", hiddenFileCount !== 1 ? "s" : ""]
+            }) : null]
+          }), index.o("p", {
+            class: "text-neutral-11 text-xs",
+            children: [kbToReadableSize(totalSize), " ", files.length > 1 ? "total" : ""]
+          })]
+        }) : index.o("div", {
+          class: "flex flex-col justify-center gap-4 pb-6 pt-5",
+          children: [index.o("header", {
+            class: "flex flex-col items-center gap-0",
+            children: [index.o("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: index.o("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"
+              })
+            }), index.o("p", {
+              class: "text-neutral-12 tracking-[-0.01em] dark:text-gray-400",
+              children: [input.config.allowMultiple ? "Select files" : "Select a file", " to upload"]
+            }), input.config.fileSizeLimitKib ? index.o("p", {
+              class: "text-neutral-10 text-xs",
+              children: ["(max ", kbToReadableSize(input.config.fileSizeLimitKib), ")"]
+            }) : null]
+          }), index.o("aside", {
+            class: "flex flex-col items-center gap-2",
+            children: [index.o("p", {
+              id: "accepted-filetypes",
+              class: "sr-only",
+              children: "Accepted file extensions"
+            }), index.o("ul", {
+              "aria-describedby": "accepted-filetypes",
+              class: "flex flex-wrap justify-center gap-2",
+              children: input.config.extensions.map((ext) => index.o("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: ext.replace(".", "")
+              }))
+            })]
+          })]
+        }), index.o("input", {
+          id: "dropzone-file",
+          onInput: async (e) => {
+            index.invariant(e.target instanceof HTMLInputElement);
+            const files2 = e.target.files ? Array.from(e.target.files) : [];
+            const filesToUpload = await Promise.allSettled(files2.map(async (file) => {
+              const data = await toBase64(file);
+              return {
+                name: file.name,
+                data,
+                sizeKb: file.size / 1e3
+              };
+            }));
+            if (filesToUpload.some(({
+              status
+            }) => status === "rejected")) {
+              return setError({
+                type: "invalid",
+                message: "Invalid file"
+              });
+            }
+            const validFiles = filesToUpload.map((promise) => promise.status === "fulfilled" ? promise.value : null).filter(Boolean);
+            setFiles(validFiles);
+          },
+          multiple: input.config.allowMultiple,
+          type: "file",
+          class: "sr-only"
+        })]
+      }), index.o(SendButton, {
+        disabled: files.length === 0
+      })]
+    }), error && index.o(InputError, {
+      onAnimationComplete: onHeightChange,
+      error
+    })]
+  });
+};
+var isCheckBoxInput = (element) => element.type === "checkbox";
+var isDateObject = (value) => value instanceof Date;
+var isNullOrUndefined = (value) => value == null;
+const isObjectType = (value) => typeof value === "object";
+var isObject = (value) => !isNullOrUndefined(value) && !Array.isArray(value) && isObjectType(value) && !isDateObject(value);
+var getEventValue = (event) => isObject(event) && event.target ? isCheckBoxInput(event.target) ? event.target.checked : event.target.value : event;
+var getNodeParentName = (name) => name.substring(0, name.search(/\.\d+(\.|$)/)) || name;
+var isNameInFieldArray = (names, name) => names.has(getNodeParentName(name));
+var isPlainObject = (tempObject) => {
+  const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
+  return isObject(prototypeCopy) && prototypeCopy.hasOwnProperty("isPrototypeOf");
+};
+var isWeb = typeof window !== "undefined" && typeof window.HTMLElement !== "undefined" && typeof document !== "undefined";
+function cloneObject(data) {
+  let copy;
+  const isArray = Array.isArray(data);
+  if (data instanceof Date) {
+    copy = new Date(data);
+  } else if (data instanceof Set) {
+    copy = new Set(data);
+  } else if (!(isWeb && (data instanceof Blob || data instanceof FileList)) && (isArray || isObject(data))) {
+    copy = isArray ? [] : {};
+    if (!isArray && !isPlainObject(data)) {
+      copy = data;
+    } else {
+      for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+          copy[key] = cloneObject(data[key]);
+        }
+      }
+    }
+  } else {
+    return data;
+  }
+  return copy;
+}
+var compact = (value) => Array.isArray(value) ? value.filter(Boolean) : [];
+var isUndefined = (val) => val === void 0;
+var get = (obj, path, defaultValue) => {
+  if (!path || !isObject(obj)) {
+    return defaultValue;
+  }
+  const result = compact(path.split(/[,[\].]+?/)).reduce((result2, key) => isNullOrUndefined(result2) ? result2 : result2[key], obj);
+  return isUndefined(result) || result === obj ? isUndefined(obj[path]) ? defaultValue : obj[path] : result;
+};
+var isBoolean = (value) => typeof value === "boolean";
+const EVENTS = {
+  BLUR: "blur",
+  FOCUS_OUT: "focusout",
+  CHANGE: "change"
+};
+const VALIDATION_MODE = {
+  onBlur: "onBlur",
+  onChange: "onChange",
+  onSubmit: "onSubmit",
+  onTouched: "onTouched",
+  all: "all"
+};
+const INPUT_VALIDATION_RULES = {
+  max: "max",
+  min: "min",
+  maxLength: "maxLength",
+  minLength: "minLength",
+  pattern: "pattern",
+  required: "required",
+  validate: "validate"
+};
+index.Cn.createContext(null);
+var getProxyFormState = (formState, control, localProxyFormState, isRoot = true) => {
+  const result = {
+    defaultValues: control._defaultValues
+  };
+  for (const key in formState) {
+    Object.defineProperty(result, key, {
+      get: () => {
+        const _key = key;
+        if (control._proxyFormState[_key] !== VALIDATION_MODE.all) {
+          control._proxyFormState[_key] = !isRoot || VALIDATION_MODE.all;
+        }
+        localProxyFormState && (localProxyFormState[_key] = true);
+        return formState[_key];
+      }
+    });
+  }
+  return result;
+};
+var isEmptyObject = (value) => isObject(value) && !Object.keys(value).length;
+var shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, isRoot) => {
+  updateFormState(formStateData);
+  const { name, ...formState } = formStateData;
+  return isEmptyObject(formState) || Object.keys(formState).length >= Object.keys(_proxyFormState).length || Object.keys(formState).find((key) => _proxyFormState[key] === (!isRoot || VALIDATION_MODE.all));
+};
+var convertToArrayPayload = (value) => Array.isArray(value) ? value : [value];
+function useSubscribe(props) {
+  const _props = index.Cn.useRef(props);
+  _props.current = props;
+  index.Cn.useEffect(() => {
+    const subscription = !props.disabled && _props.current.subject && _props.current.subject.subscribe({
+      next: _props.current.next
+    });
+    return () => {
+      subscription && subscription.unsubscribe();
+    };
+  }, [props.disabled]);
+}
+var isString = (value) => typeof value === "string";
+var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) => {
+  if (isString(names)) {
+    isGlobal && _names.watch.add(names);
+    return get(formValues, names, defaultValue);
+  }
+  if (Array.isArray(names)) {
+    return names.map((fieldName) => (isGlobal && _names.watch.add(fieldName), get(formValues, fieldName)));
+  }
+  isGlobal && (_names.watchAll = true);
+  return formValues;
+};
+var isKey = (value) => /^\w*$/.test(value);
+var stringToPath = (input) => compact(input.replace(/["|']|\]/g, "").split(/\.|\[/));
+function set(object, path, value) {
+  let index2 = -1;
+  const tempPath = isKey(path) ? [path] : stringToPath(path);
+  const length = tempPath.length;
+  const lastIndex = length - 1;
+  while (++index2 < length) {
+    const key = tempPath[index2];
+    let newValue = value;
+    if (index2 !== lastIndex) {
+      const objValue = object[key];
+      newValue = isObject(objValue) || Array.isArray(objValue) ? objValue : !isNaN(+tempPath[index2 + 1]) ? [] : {};
+    }
+    object[key] = newValue;
+    object = object[key];
+  }
+  return object;
+}
+var appendErrors = (name, validateAllFieldCriteria, errors2, type, message) => validateAllFieldCriteria ? {
+  ...errors2[name],
+  types: {
+    ...errors2[name] && errors2[name].types ? errors2[name].types : {},
+    [type]: message || true
+  }
+} : {};
+var getValidationModes = (mode) => ({
+  isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,
+  isOnBlur: mode === VALIDATION_MODE.onBlur,
+  isOnChange: mode === VALIDATION_MODE.onChange,
+  isOnAll: mode === VALIDATION_MODE.all,
+  isOnTouch: mode === VALIDATION_MODE.onTouched
+});
+var isWatched = (name, _names, isBlurEvent) => !isBlurEvent && (_names.watchAll || _names.watch.has(name) || [..._names.watch].some((watchName) => name.startsWith(watchName) && /^\.\w+/.test(name.slice(watchName.length))));
+const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
+  for (const key of fieldsNames || Object.keys(fields)) {
+    const field = get(fields, key);
+    if (field) {
+      const { _f, ...currentField } = field;
+      if (_f) {
+        if (_f.refs && _f.refs[0] && action(_f.refs[0], key) && !abortEarly) {
+          break;
+        } else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) {
+          break;
+        }
+      } else if (isObject(currentField)) {
+        iterateFieldsByAction(currentField, action);
+      }
+    }
+  }
+};
+var updateFieldArrayRootError = (errors2, error, name) => {
+  const fieldArrayErrors = compact(get(errors2, name));
+  set(fieldArrayErrors, "root", error[name]);
+  set(errors2, name, fieldArrayErrors);
+  return errors2;
+};
+var isFileInput = (element) => element.type === "file";
+var isFunction = (value) => typeof value === "function";
+var isHTMLElement = (value) => {
+  if (!isWeb) {
+    return false;
+  }
+  const owner = value ? value.ownerDocument : 0;
+  return value instanceof (owner && owner.defaultView ? owner.defaultView.HTMLElement : HTMLElement);
+};
+var isMessage = (value) => isString(value);
+var isRadioInput = (element) => element.type === "radio";
+var isRegex = (value) => value instanceof RegExp;
+const defaultResult = {
+  value: false,
+  isValid: false
+};
+const validResult = { value: true, isValid: true };
+var getCheckboxValue = (options2) => {
+  if (Array.isArray(options2)) {
+    if (options2.length > 1) {
+      const values = options2.filter((option) => option && option.checked && !option.disabled).map((option) => option.value);
+      return { value: values, isValid: !!values.length };
+    }
+    return options2[0].checked && !options2[0].disabled ? (
+      // @ts-expect-error expected to work in the browser
+      options2[0].attributes && !isUndefined(options2[0].attributes.value) ? isUndefined(options2[0].value) || options2[0].value === "" ? validResult : { value: options2[0].value, isValid: true } : validResult
+    ) : defaultResult;
+  }
+  return defaultResult;
+};
+const defaultReturn = {
+  isValid: false,
+  value: null
+};
+var getRadioValue = (options2) => Array.isArray(options2) ? options2.reduce((previous, option) => option && option.checked && !option.disabled ? {
+  isValid: true,
+  value: option.value
+} : previous, defaultReturn) : defaultReturn;
+function getValidateError(result, ref, type = "validate") {
+  if (isMessage(result) || Array.isArray(result) && result.every(isMessage) || isBoolean(result) && !result) {
+    return {
+      type,
+      message: isMessage(result) ? result : "",
+      ref
+    };
+  }
+}
+var getValueAndMessage = (validationData) => isObject(validationData) && !isRegex(validationData) ? validationData : {
+  value: validationData,
+  message: ""
+};
+var validateField = async (field, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {
+  const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, disabled } = field._f;
+  const inputValue = get(formValues, name);
+  if (!mount || disabled) {
+    return {};
+  }
+  const inputRef = refs ? refs[0] : ref;
+  const setCustomValidity = (message) => {
+    if (shouldUseNativeValidation && inputRef.reportValidity) {
+      inputRef.setCustomValidity(isBoolean(message) ? "" : message || "");
+      inputRef.reportValidity();
+    }
+  };
+  const error = {};
+  const isRadio = isRadioInput(ref);
+  const isCheckBox = isCheckBoxInput(ref);
+  const isRadioOrCheckbox2 = isRadio || isCheckBox;
+  const isEmpty = (valueAsNumber || isFileInput(ref)) && isUndefined(ref.value) && isUndefined(inputValue) || isHTMLElement(ref) && ref.value === "" || inputValue === "" || Array.isArray(inputValue) && !inputValue.length;
+  const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);
+  const getMinMaxMessage = (exceedMax, maxLengthMessage, minLengthMessage, maxType = INPUT_VALIDATION_RULES.maxLength, minType = INPUT_VALIDATION_RULES.minLength) => {
+    const message = exceedMax ? maxLengthMessage : minLengthMessage;
+    error[name] = {
+      type: exceedMax ? maxType : minType,
+      message,
+      ref,
+      ...appendErrorsCurry(exceedMax ? maxType : minType, message)
+    };
+  };
+  if (isFieldArray ? !Array.isArray(inputValue) || !inputValue.length : required && (!isRadioOrCheckbox2 && (isEmpty || isNullOrUndefined(inputValue)) || isBoolean(inputValue) && !inputValue || isCheckBox && !getCheckboxValue(refs).isValid || isRadio && !getRadioValue(refs).isValid)) {
+    const { value, message } = isMessage(required) ? { value: !!required, message: required } : getValueAndMessage(required);
+    if (value) {
+      error[name] = {
+        type: INPUT_VALIDATION_RULES.required,
+        message,
+        ref: inputRef,
+        ...appendErrorsCurry(INPUT_VALIDATION_RULES.required, message)
+      };
+      if (!validateAllFieldCriteria) {
+        setCustomValidity(message);
+        return error;
+      }
+    }
+  }
+  if (!isEmpty && (!isNullOrUndefined(min) || !isNullOrUndefined(max))) {
+    let exceedMax;
+    let exceedMin;
+    const maxOutput = getValueAndMessage(max);
+    const minOutput = getValueAndMessage(min);
+    if (!isNullOrUndefined(inputValue) && !isNaN(inputValue)) {
+      const valueNumber = ref.valueAsNumber || (inputValue ? +inputValue : inputValue);
+      if (!isNullOrUndefined(maxOutput.value)) {
+        exceedMax = valueNumber > maxOutput.value;
+      }
+      if (!isNullOrUndefined(minOutput.value)) {
+        exceedMin = valueNumber < minOutput.value;
+      }
+    } else {
+      const valueDate = ref.valueAsDate || new Date(inputValue);
+      const convertTimeToDate = (time) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + time);
+      const isTime = ref.type == "time";
+      const isWeek = ref.type == "week";
+      if (isString(maxOutput.value) && inputValue) {
+        exceedMax = isTime ? convertTimeToDate(inputValue) > convertTimeToDate(maxOutput.value) : isWeek ? inputValue > maxOutput.value : valueDate > new Date(maxOutput.value);
+      }
+      if (isString(minOutput.value) && inputValue) {
+        exceedMin = isTime ? convertTimeToDate(inputValue) < convertTimeToDate(minOutput.value) : isWeek ? inputValue < minOutput.value : valueDate < new Date(minOutput.value);
+      }
+    }
+    if (exceedMax || exceedMin) {
+      getMinMaxMessage(!!exceedMax, maxOutput.message, minOutput.message, INPUT_VALIDATION_RULES.max, INPUT_VALIDATION_RULES.min);
+      if (!validateAllFieldCriteria) {
+        setCustomValidity(error[name].message);
+        return error;
+      }
+    }
+  }
+  if ((maxLength || minLength) && !isEmpty && (isString(inputValue) || isFieldArray && Array.isArray(inputValue))) {
+    const maxLengthOutput = getValueAndMessage(maxLength);
+    const minLengthOutput = getValueAndMessage(minLength);
+    const exceedMax = !isNullOrUndefined(maxLengthOutput.value) && inputValue.length > +maxLengthOutput.value;
+    const exceedMin = !isNullOrUndefined(minLengthOutput.value) && inputValue.length < +minLengthOutput.value;
+    if (exceedMax || exceedMin) {
+      getMinMaxMessage(exceedMax, maxLengthOutput.message, minLengthOutput.message);
+      if (!validateAllFieldCriteria) {
+        setCustomValidity(error[name].message);
+        return error;
+      }
+    }
+  }
+  if (pattern && !isEmpty && isString(inputValue)) {
+    const { value: patternValue, message } = getValueAndMessage(pattern);
+    if (isRegex(patternValue) && !inputValue.match(patternValue)) {
+      error[name] = {
+        type: INPUT_VALIDATION_RULES.pattern,
+        message,
+        ref,
+        ...appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, message)
+      };
+      if (!validateAllFieldCriteria) {
+        setCustomValidity(message);
+        return error;
+      }
+    }
+  }
+  if (validate) {
+    if (isFunction(validate)) {
+      const result = await validate(inputValue, formValues);
+      const validateError = getValidateError(result, inputRef);
+      if (validateError) {
+        error[name] = {
+          ...validateError,
+          ...appendErrorsCurry(INPUT_VALIDATION_RULES.validate, validateError.message)
+        };
+        if (!validateAllFieldCriteria) {
+          setCustomValidity(validateError.message);
+          return error;
+        }
+      }
+    } else if (isObject(validate)) {
+      let validationResult = {};
+      for (const key in validate) {
+        if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) {
+          break;
+        }
+        const validateError = getValidateError(await validate[key](inputValue, formValues), inputRef, key);
+        if (validateError) {
+          validationResult = {
+            ...validateError,
+            ...appendErrorsCurry(key, validateError.message)
+          };
+          setCustomValidity(validateError.message);
+          if (validateAllFieldCriteria) {
+            error[name] = validationResult;
+          }
+        }
+      }
+      if (!isEmptyObject(validationResult)) {
+        error[name] = {
+          ref: inputRef,
+          ...validationResult
+        };
+        if (!validateAllFieldCriteria) {
+          return error;
+        }
+      }
+    }
+  }
+  setCustomValidity(true);
+  return error;
+};
+function baseGet(object, updatePath) {
+  const length = updatePath.slice(0, -1).length;
+  let index2 = 0;
+  while (index2 < length) {
+    object = isUndefined(object) ? index2++ : object[updatePath[index2++]];
+  }
+  return object;
+}
+function isEmptyArray(obj) {
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key) && !isUndefined(obj[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function unset(object, path) {
+  const paths = Array.isArray(path) ? path : isKey(path) ? [path] : stringToPath(path);
+  const childObject = paths.length === 1 ? object : baseGet(object, paths);
+  const index2 = paths.length - 1;
+  const key = paths[index2];
+  if (childObject) {
+    delete childObject[key];
+  }
+  if (index2 !== 0 && (isObject(childObject) && isEmptyObject(childObject) || Array.isArray(childObject) && isEmptyArray(childObject))) {
+    unset(object, paths.slice(0, -1));
+  }
+  return object;
+}
+function createSubject() {
+  let _observers = [];
+  const next = (value) => {
+    for (const observer of _observers) {
+      observer.next && observer.next(value);
+    }
+  };
+  const subscribe = (observer) => {
+    _observers.push(observer);
+    return {
+      unsubscribe: () => {
+        _observers = _observers.filter((o2) => o2 !== observer);
+      }
+    };
+  };
+  const unsubscribe = () => {
+    _observers = [];
+  };
+  return {
+    get observers() {
+      return _observers;
+    },
+    next,
+    subscribe,
+    unsubscribe
+  };
+}
+var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
+function deepEqual(object1, object2) {
+  if (isPrimitive(object1) || isPrimitive(object2)) {
+    return object1 === object2;
+  }
+  if (isDateObject(object1) && isDateObject(object2)) {
+    return object1.getTime() === object2.getTime();
+  }
+  const keys1 = Object.keys(object1);
+  const keys2 = Object.keys(object2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    const val1 = object1[key];
+    if (!keys2.includes(key)) {
+      return false;
+    }
+    if (key !== "ref") {
+      const val2 = object2[key];
+      if (isDateObject(val1) && isDateObject(val2) || isObject(val1) && isObject(val2) || Array.isArray(val1) && Array.isArray(val2) ? !deepEqual(val1, val2) : val1 !== val2) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var isMultipleSelect = (element) => element.type === `select-multiple`;
+var isRadioOrCheckbox = (ref) => isRadioInput(ref) || isCheckBoxInput(ref);
+var live = (ref) => isHTMLElement(ref) && ref.isConnected;
+var objectHasFunction = (data) => {
+  for (const key in data) {
+    if (isFunction(data[key])) {
+      return true;
+    }
+  }
+  return false;
+};
+function markFieldsDirty(data, fields = {}) {
+  const isParentNodeArray = Array.isArray(data);
+  if (isObject(data) || isParentNodeArray) {
+    for (const key in data) {
+      if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) {
+        fields[key] = Array.isArray(data[key]) ? [] : {};
+        markFieldsDirty(data[key], fields[key]);
+      } else if (!isNullOrUndefined(data[key])) {
+        fields[key] = true;
+      }
+    }
+  }
+  return fields;
+}
+function getDirtyFieldsFromDefaultValues(data, formValues, dirtyFieldsFromValues) {
+  const isParentNodeArray = Array.isArray(data);
+  if (isObject(data) || isParentNodeArray) {
+    for (const key in data) {
+      if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) {
+        if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) {
+          dirtyFieldsFromValues[key] = Array.isArray(data[key]) ? markFieldsDirty(data[key], []) : { ...markFieldsDirty(data[key]) };
+        } else {
+          getDirtyFieldsFromDefaultValues(data[key], isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
+        }
+      } else {
+        dirtyFieldsFromValues[key] = !deepEqual(data[key], formValues[key]);
+      }
+    }
+  }
+  return dirtyFieldsFromValues;
+}
+var getDirtyFields = (defaultValues, formValues) => getDirtyFieldsFromDefaultValues(defaultValues, formValues, markFieldsDirty(formValues));
+var getFieldValueAs = (value, { valueAsNumber, valueAsDate, setValueAs }) => isUndefined(value) ? value : valueAsNumber ? value === "" ? NaN : value ? +value : value : valueAsDate && isString(value) ? new Date(value) : setValueAs ? setValueAs(value) : value;
+function getFieldValue(_f) {
+  const ref = _f.ref;
+  if (_f.refs ? _f.refs.every((ref2) => ref2.disabled) : ref.disabled) {
+    return;
+  }
+  if (isFileInput(ref)) {
+    return ref.files;
+  }
+  if (isRadioInput(ref)) {
+    return getRadioValue(_f.refs).value;
+  }
+  if (isMultipleSelect(ref)) {
+    return [...ref.selectedOptions].map(({ value }) => value);
+  }
+  if (isCheckBoxInput(ref)) {
+    return getCheckboxValue(_f.refs).value;
+  }
+  return getFieldValueAs(isUndefined(ref.value) ? _f.ref.value : ref.value, _f);
+}
+var getResolverOptions = (fieldsNames, _fields, criteriaMode, shouldUseNativeValidation) => {
+  const fields = {};
+  for (const name of fieldsNames) {
+    const field = get(_fields, name);
+    field && set(fields, name, field._f);
+  }
+  return {
+    criteriaMode,
+    names: [...fieldsNames],
+    fields,
+    shouldUseNativeValidation
+  };
+};
+var getRuleValue = (rule) => isUndefined(rule) ? rule : isRegex(rule) ? rule.source : isObject(rule) ? isRegex(rule.value) ? rule.value.source : rule.value : rule;
+var hasValidation = (options2) => options2.mount && (options2.required || options2.min || options2.max || options2.maxLength || options2.minLength || options2.pattern || options2.validate);
+function schemaErrorLookup(errors2, _fields, name) {
+  const error = get(errors2, name);
+  if (error || isKey(name)) {
+    return {
+      error,
+      name
+    };
+  }
+  const names = name.split(".");
+  while (names.length) {
+    const fieldName = names.join(".");
+    const field = get(_fields, fieldName);
+    const foundError = get(errors2, fieldName);
+    if (field && !Array.isArray(field) && name !== fieldName) {
+      return { name };
+    }
+    if (foundError && foundError.type) {
+      return {
+        name: fieldName,
+        error: foundError
+      };
+    }
+    names.pop();
+  }
+  return {
+    name
+  };
+}
+var skipValidation = (isBlurEvent, isTouched, isSubmitted, reValidateMode, mode) => {
+  if (mode.isOnAll) {
+    return false;
+  } else if (!isSubmitted && mode.isOnTouch) {
+    return !(isTouched || isBlurEvent);
+  } else if (isSubmitted ? reValidateMode.isOnBlur : mode.isOnBlur) {
+    return !isBlurEvent;
+  } else if (isSubmitted ? reValidateMode.isOnChange : mode.isOnChange) {
+    return isBlurEvent;
+  }
+  return true;
+};
+var unsetEmptyArray = (ref, name) => !compact(get(ref, name)).length && unset(ref, name);
+const defaultOptions = {
+  mode: VALIDATION_MODE.onSubmit,
+  reValidateMode: VALIDATION_MODE.onChange,
+  shouldFocusError: true
+};
+function createFormControl(props = {}, flushRootRender) {
+  let _options = {
+    ...defaultOptions,
+    ...props
+  };
+  let _formState = {
+    submitCount: 0,
+    isDirty: false,
+    isLoading: isFunction(_options.defaultValues),
+    isValidating: false,
+    isSubmitted: false,
+    isSubmitting: false,
+    isSubmitSuccessful: false,
+    isValid: false,
+    touchedFields: {},
+    dirtyFields: {},
+    errors: {},
+    disabled: false
+  };
+  let _fields = {};
+  let _defaultValues = isObject(_options.defaultValues) || isObject(_options.values) ? cloneObject(_options.defaultValues || _options.values) || {} : {};
+  let _formValues = _options.shouldUnregister ? {} : cloneObject(_defaultValues);
+  let _state = {
+    action: false,
+    mount: false,
+    watch: false
+  };
+  let _names = {
+    mount: /* @__PURE__ */ new Set(),
+    unMount: /* @__PURE__ */ new Set(),
+    array: /* @__PURE__ */ new Set(),
+    watch: /* @__PURE__ */ new Set()
+  };
+  let delayErrorCallback;
+  let timer = 0;
+  const _proxyFormState = {
+    isDirty: false,
+    dirtyFields: false,
+    touchedFields: false,
+    isValidating: false,
+    isValid: false,
+    errors: false
+  };
+  const _subjects = {
+    values: createSubject(),
+    array: createSubject(),
+    state: createSubject()
+  };
+  const shouldCaptureDirtyFields = props.resetOptions && props.resetOptions.keepDirtyValues;
+  const validationModeBeforeSubmit = getValidationModes(_options.mode);
+  const validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
+  const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
+  const debounce = (callback) => (wait) => {
+    clearTimeout(timer);
+    timer = setTimeout(callback, wait);
+  };
+  const _updateValid = async (shouldUpdateValid) => {
+    if (_proxyFormState.isValid || shouldUpdateValid) {
+      const isValid = _options.resolver ? isEmptyObject((await _executeSchema()).errors) : await executeBuiltInValidation(_fields, true);
+      if (isValid !== _formState.isValid) {
+        _subjects.state.next({
+          isValid
+        });
+      }
+    }
+  };
+  const _updateIsValidating = (value) => _proxyFormState.isValidating && _subjects.state.next({
+    isValidating: value
+  });
+  const _updateFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {
+    if (args && method) {
+      _state.action = true;
+      if (shouldUpdateFieldsAndState && Array.isArray(get(_fields, name))) {
+        const fieldValues = method(get(_fields, name), args.argA, args.argB);
+        shouldSetValues && set(_fields, name, fieldValues);
+      }
+      if (shouldUpdateFieldsAndState && Array.isArray(get(_formState.errors, name))) {
+        const errors2 = method(get(_formState.errors, name), args.argA, args.argB);
+        shouldSetValues && set(_formState.errors, name, errors2);
+        unsetEmptyArray(_formState.errors, name);
+      }
+      if (_proxyFormState.touchedFields && shouldUpdateFieldsAndState && Array.isArray(get(_formState.touchedFields, name))) {
+        const touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB);
+        shouldSetValues && set(_formState.touchedFields, name, touchedFields);
+      }
+      if (_proxyFormState.dirtyFields) {
+        _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+      }
+      _subjects.state.next({
+        name,
+        isDirty: _getDirty(name, values),
+        dirtyFields: _formState.dirtyFields,
+        errors: _formState.errors,
+        isValid: _formState.isValid
+      });
+    } else {
+      set(_formValues, name, values);
+    }
+  };
+  const updateErrors = (name, error) => {
+    set(_formState.errors, name, error);
+    _subjects.state.next({
+      errors: _formState.errors
+    });
+  };
+  const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => {
+    const field = get(_fields, name);
+    if (field) {
+      const defaultValue = get(_formValues, name, isUndefined(value) ? get(_defaultValues, name) : value);
+      isUndefined(defaultValue) || ref && ref.defaultChecked || shouldSkipSetValueAs ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f)) : setFieldValue(name, defaultValue);
+      _state.mount && _updateValid();
+    }
+  };
+  const updateTouchAndDirty = (name, fieldValue, isBlurEvent, shouldDirty, shouldRender) => {
+    let shouldUpdateField = false;
+    let isPreviousDirty = false;
+    const output = {
+      name
+    };
+    if (!isBlurEvent || shouldDirty) {
+      if (_proxyFormState.isDirty) {
+        isPreviousDirty = _formState.isDirty;
+        _formState.isDirty = output.isDirty = _getDirty();
+        shouldUpdateField = isPreviousDirty !== output.isDirty;
+      }
+      const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
+      isPreviousDirty = get(_formState.dirtyFields, name);
+      isCurrentFieldPristine ? unset(_formState.dirtyFields, name) : set(_formState.dirtyFields, name, true);
+      output.dirtyFields = _formState.dirtyFields;
+      shouldUpdateField = shouldUpdateField || _proxyFormState.dirtyFields && isPreviousDirty !== !isCurrentFieldPristine;
+    }
+    if (isBlurEvent) {
+      const isPreviousFieldTouched = get(_formState.touchedFields, name);
+      if (!isPreviousFieldTouched) {
+        set(_formState.touchedFields, name, isBlurEvent);
+        output.touchedFields = _formState.touchedFields;
+        shouldUpdateField = shouldUpdateField || _proxyFormState.touchedFields && isPreviousFieldTouched !== isBlurEvent;
+      }
+    }
+    shouldUpdateField && shouldRender && _subjects.state.next(output);
+    return shouldUpdateField ? output : {};
+  };
+  const shouldRenderByError = (name, isValid, error, fieldState) => {
+    const previousFieldError = get(_formState.errors, name);
+    const shouldUpdateValid = _proxyFormState.isValid && isBoolean(isValid) && _formState.isValid !== isValid;
+    if (props.delayError && error) {
+      delayErrorCallback = debounce(() => updateErrors(name, error));
+      delayErrorCallback(props.delayError);
+    } else {
+      clearTimeout(timer);
+      delayErrorCallback = null;
+      error ? set(_formState.errors, name, error) : unset(_formState.errors, name);
+    }
+    if ((error ? !deepEqual(previousFieldError, error) : previousFieldError) || !isEmptyObject(fieldState) || shouldUpdateValid) {
+      const updatedFormState = {
+        ...fieldState,
+        ...shouldUpdateValid && isBoolean(isValid) ? { isValid } : {},
+        errors: _formState.errors,
+        name
+      };
+      _formState = {
+        ..._formState,
+        ...updatedFormState
+      };
+      _subjects.state.next(updatedFormState);
+    }
+    _updateIsValidating(false);
+  };
+  const _executeSchema = async (name) => _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
+  const executeSchemaAndUpdateState = async (names) => {
+    const { errors: errors2 } = await _executeSchema(names);
+    if (names) {
+      for (const name of names) {
+        const error = get(errors2, name);
+        error ? set(_formState.errors, name, error) : unset(_formState.errors, name);
+      }
+    } else {
+      _formState.errors = errors2;
+    }
+    return errors2;
+  };
+  const executeBuiltInValidation = async (fields, shouldOnlyCheckValid, context = {
+    valid: true
+  }) => {
+    for (const name in fields) {
+      const field = fields[name];
+      if (field) {
+        const { _f, ...fieldValue } = field;
+        if (_f) {
+          const isFieldArrayRoot = _names.array.has(_f.name);
+          const fieldError = await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
+          if (fieldError[_f.name]) {
+            context.valid = false;
+            if (shouldOnlyCheckValid) {
+              break;
+            }
+          }
+          !shouldOnlyCheckValid && (get(fieldError, _f.name) ? isFieldArrayRoot ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name) : set(_formState.errors, _f.name, fieldError[_f.name]) : unset(_formState.errors, _f.name));
+        }
+        fieldValue && await executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context);
+      }
+    }
+    return context.valid;
+  };
+  const _removeUnmounted = () => {
+    for (const name of _names.unMount) {
+      const field = get(_fields, name);
+      field && (field._f.refs ? field._f.refs.every((ref) => !live(ref)) : !live(field._f.ref)) && unregister(name);
+    }
+    _names.unMount = /* @__PURE__ */ new Set();
+  };
+  const _getDirty = (name, data) => (name && data && set(_formValues, name, data), !deepEqual(getValues(), _defaultValues));
+  const _getWatch = (names, defaultValue, isGlobal) => generateWatchOutput(names, _names, {
+    ..._state.mount ? _formValues : isUndefined(defaultValue) ? _defaultValues : isString(names) ? { [names]: defaultValue } : defaultValue
+  }, isGlobal, defaultValue);
+  const _getFieldArray = (name) => compact(get(_state.mount ? _formValues : _defaultValues, name, props.shouldUnregister ? get(_defaultValues, name, []) : []));
+  const setFieldValue = (name, value, options2 = {}) => {
+    const field = get(_fields, name);
+    let fieldValue = value;
+    if (field) {
+      const fieldReference = field._f;
+      if (fieldReference) {
+        !fieldReference.disabled && set(_formValues, name, getFieldValueAs(value, fieldReference));
+        fieldValue = isHTMLElement(fieldReference.ref) && isNullOrUndefined(value) ? "" : value;
+        if (isMultipleSelect(fieldReference.ref)) {
+          [...fieldReference.ref.options].forEach((optionRef) => optionRef.selected = fieldValue.includes(optionRef.value));
+        } else if (fieldReference.refs) {
+          if (isCheckBoxInput(fieldReference.ref)) {
+            fieldReference.refs.length > 1 ? fieldReference.refs.forEach((checkboxRef) => (!checkboxRef.defaultChecked || !checkboxRef.disabled) && (checkboxRef.checked = Array.isArray(fieldValue) ? !!fieldValue.find((data) => data === checkboxRef.value) : fieldValue === checkboxRef.value)) : fieldReference.refs[0] && (fieldReference.refs[0].checked = !!fieldValue);
+          } else {
+            fieldReference.refs.forEach((radioRef) => radioRef.checked = radioRef.value === fieldValue);
+          }
+        } else if (isFileInput(fieldReference.ref)) {
+          fieldReference.ref.value = "";
+        } else {
+          fieldReference.ref.value = fieldValue;
+          if (!fieldReference.ref.type) {
+            _subjects.values.next({
+              name,
+              values: { ..._formValues }
+            });
+          }
+        }
+      }
+    }
+    (options2.shouldDirty || options2.shouldTouch) && updateTouchAndDirty(name, fieldValue, options2.shouldTouch, options2.shouldDirty, true);
+    options2.shouldValidate && trigger(name);
+  };
+  const setValues = (name, value, options2) => {
+    for (const fieldKey in value) {
+      const fieldValue = value[fieldKey];
+      const fieldName = `${name}.${fieldKey}`;
+      const field = get(_fields, fieldName);
+      (_names.array.has(name) || !isPrimitive(fieldValue) || field && !field._f) && !isDateObject(fieldValue) ? setValues(fieldName, fieldValue, options2) : setFieldValue(fieldName, fieldValue, options2);
+    }
+  };
+  const setValue = (name, value, options2 = {}) => {
+    const field = get(_fields, name);
+    const isFieldArray = _names.array.has(name);
+    const cloneValue = cloneObject(value);
+    set(_formValues, name, cloneValue);
+    if (isFieldArray) {
+      _subjects.array.next({
+        name,
+        values: { ..._formValues }
+      });
+      if ((_proxyFormState.isDirty || _proxyFormState.dirtyFields) && options2.shouldDirty) {
+        _subjects.state.next({
+          name,
+          dirtyFields: getDirtyFields(_defaultValues, _formValues),
+          isDirty: _getDirty(name, cloneValue)
+        });
+      }
+    } else {
+      field && !field._f && !isNullOrUndefined(cloneValue) ? setValues(name, cloneValue, options2) : setFieldValue(name, cloneValue, options2);
+    }
+    isWatched(name, _names) && _subjects.state.next({ ..._formState });
+    _subjects.values.next({
+      name,
+      values: { ..._formValues }
+    });
+    !_state.mount && flushRootRender();
+  };
+  const onChange = async (event) => {
+    const target = event.target;
+    let name = target.name;
+    let isFieldValueUpdated = true;
+    const field = get(_fields, name);
+    const getCurrentFieldValue = () => target.type ? getFieldValue(field._f) : getEventValue(event);
+    const _updateIsFieldValueUpdated = (fieldValue) => {
+      isFieldValueUpdated = Number.isNaN(fieldValue) || fieldValue === get(_formValues, name, fieldValue);
+    };
+    if (field) {
+      let error;
+      let isValid;
+      const fieldValue = getCurrentFieldValue();
+      const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
+      const shouldSkipValidation = !hasValidation(field._f) && !_options.resolver && !get(_formState.errors, name) && !field._f.deps || skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);
+      const watched = isWatched(name, _names, isBlurEvent);
+      set(_formValues, name, fieldValue);
+      if (isBlurEvent) {
+        field._f.onBlur && field._f.onBlur(event);
+        delayErrorCallback && delayErrorCallback(0);
+      } else if (field._f.onChange) {
+        field._f.onChange(event);
+      }
+      const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent, false);
+      const shouldRender = !isEmptyObject(fieldState) || watched;
+      !isBlurEvent && _subjects.values.next({
+        name,
+        type: event.type,
+        values: { ..._formValues }
+      });
+      if (shouldSkipValidation) {
+        _proxyFormState.isValid && _updateValid();
+        return shouldRender && _subjects.state.next({ name, ...watched ? {} : fieldState });
+      }
+      !isBlurEvent && watched && _subjects.state.next({ ..._formState });
+      _updateIsValidating(true);
+      if (_options.resolver) {
+        const { errors: errors2 } = await _executeSchema([name]);
+        _updateIsFieldValueUpdated(fieldValue);
+        if (isFieldValueUpdated) {
+          const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
+          const errorLookupResult = schemaErrorLookup(errors2, _fields, previousErrorLookupResult.name || name);
+          error = errorLookupResult.error;
+          name = errorLookupResult.name;
+          isValid = isEmptyObject(errors2);
+        }
+      } else {
+        error = (await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
+        _updateIsFieldValueUpdated(fieldValue);
+        if (isFieldValueUpdated) {
+          if (error) {
+            isValid = false;
+          } else if (_proxyFormState.isValid) {
+            isValid = await executeBuiltInValidation(_fields, true);
+          }
+        }
+      }
+      if (isFieldValueUpdated) {
+        field._f.deps && trigger(field._f.deps);
+        shouldRenderByError(name, isValid, error, fieldState);
+      }
+    }
+  };
+  const _focusInput = (ref, key) => {
+    if (get(_formState.errors, key) && ref.focus) {
+      ref.focus();
+      return 1;
+    }
+    return;
+  };
+  const trigger = async (name, options2 = {}) => {
+    let isValid;
+    let validationResult;
+    const fieldNames = convertToArrayPayload(name);
+    _updateIsValidating(true);
+    if (_options.resolver) {
+      const errors2 = await executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames);
+      isValid = isEmptyObject(errors2);
+      validationResult = name ? !fieldNames.some((name2) => get(errors2, name2)) : isValid;
+    } else if (name) {
+      validationResult = (await Promise.all(fieldNames.map(async (fieldName) => {
+        const field = get(_fields, fieldName);
+        return await executeBuiltInValidation(field && field._f ? { [fieldName]: field } : field);
+      }))).every(Boolean);
+      !(!validationResult && !_formState.isValid) && _updateValid();
+    } else {
+      validationResult = isValid = await executeBuiltInValidation(_fields);
+    }
+    _subjects.state.next({
+      ...!isString(name) || _proxyFormState.isValid && isValid !== _formState.isValid ? {} : { name },
+      ..._options.resolver || !name ? { isValid } : {},
+      errors: _formState.errors,
+      isValidating: false
+    });
+    options2.shouldFocus && !validationResult && iterateFieldsByAction(_fields, _focusInput, name ? fieldNames : _names.mount);
+    return validationResult;
+  };
+  const getValues = (fieldNames) => {
+    const values = {
+      ..._defaultValues,
+      ..._state.mount ? _formValues : {}
+    };
+    return isUndefined(fieldNames) ? values : isString(fieldNames) ? get(values, fieldNames) : fieldNames.map((name) => get(values, name));
+  };
+  const getFieldState = (name, formState) => ({
+    invalid: !!get((formState || _formState).errors, name),
+    isDirty: !!get((formState || _formState).dirtyFields, name),
+    isTouched: !!get((formState || _formState).touchedFields, name),
+    error: get((formState || _formState).errors, name)
+  });
+  const clearErrors = (name) => {
+    name && convertToArrayPayload(name).forEach((inputName) => unset(_formState.errors, inputName));
+    _subjects.state.next({
+      errors: name ? _formState.errors : {}
+    });
+  };
+  const setError = (name, error, options2) => {
+    const ref = (get(_fields, name, { _f: {} })._f || {}).ref;
+    set(_formState.errors, name, {
+      ...error,
+      ref
+    });
+    _subjects.state.next({
+      name,
+      errors: _formState.errors,
+      isValid: false
+    });
+    options2 && options2.shouldFocus && ref && ref.focus && ref.focus();
+  };
+  const watch = (name, defaultValue) => isFunction(name) ? _subjects.values.subscribe({
+    next: (payload) => name(_getWatch(void 0, defaultValue), payload)
+  }) : _getWatch(name, defaultValue, true);
+  const unregister = (name, options2 = {}) => {
+    for (const fieldName of name ? convertToArrayPayload(name) : _names.mount) {
+      _names.mount.delete(fieldName);
+      _names.array.delete(fieldName);
+      if (!options2.keepValue) {
+        unset(_fields, fieldName);
+        unset(_formValues, fieldName);
+      }
+      !options2.keepError && unset(_formState.errors, fieldName);
+      !options2.keepDirty && unset(_formState.dirtyFields, fieldName);
+      !options2.keepTouched && unset(_formState.touchedFields, fieldName);
+      !_options.shouldUnregister && !options2.keepDefaultValue && unset(_defaultValues, fieldName);
+    }
+    _subjects.values.next({
+      values: { ..._formValues }
+    });
+    _subjects.state.next({
+      ..._formState,
+      ...!options2.keepDirty ? {} : { isDirty: _getDirty() }
+    });
+    !options2.keepIsValid && _updateValid();
+  };
+  const _updateDisabledField = ({ disabled, name, field, fields, value }) => {
+    if (isBoolean(disabled)) {
+      const inputValue = disabled ? void 0 : isUndefined(value) ? getFieldValue(field ? field._f : get(fields, name)._f) : value;
+      set(_formValues, name, inputValue);
+      updateTouchAndDirty(name, inputValue, false, false, true);
+    }
+  };
+  const register = (name, options2 = {}) => {
+    let field = get(_fields, name);
+    const disabledIsDefined = isBoolean(options2.disabled);
+    set(_fields, name, {
+      ...field || {},
+      _f: {
+        ...field && field._f ? field._f : { ref: { name } },
+        name,
+        mount: true,
+        ...options2
+      }
+    });
+    _names.mount.add(name);
+    if (field) {
+      _updateDisabledField({
+        field,
+        disabled: options2.disabled,
+        name
+      });
+    } else {
+      updateValidAndValue(name, true, options2.value);
+    }
+    return {
+      ...disabledIsDefined ? { disabled: options2.disabled } : {},
+      ..._options.progressive ? {
+        required: !!options2.required,
+        min: getRuleValue(options2.min),
+        max: getRuleValue(options2.max),
+        minLength: getRuleValue(options2.minLength),
+        maxLength: getRuleValue(options2.maxLength),
+        pattern: getRuleValue(options2.pattern)
+      } : {},
+      name,
+      onChange,
+      onBlur: onChange,
+      ref: (ref) => {
+        if (ref) {
+          register(name, options2);
+          field = get(_fields, name);
+          const fieldRef = isUndefined(ref.value) ? ref.querySelectorAll ? ref.querySelectorAll("input,select,textarea")[0] || ref : ref : ref;
+          const radioOrCheckbox = isRadioOrCheckbox(fieldRef);
+          const refs = field._f.refs || [];
+          if (radioOrCheckbox ? refs.find((option) => option === fieldRef) : fieldRef === field._f.ref) {
+            return;
+          }
+          set(_fields, name, {
+            _f: {
+              ...field._f,
+              ...radioOrCheckbox ? {
+                refs: [
+                  ...refs.filter(live),
+                  fieldRef,
+                  ...Array.isArray(get(_defaultValues, name)) ? [{}] : []
+                ],
+                ref: { type: fieldRef.type, name }
+              } : { ref: fieldRef }
+            }
+          });
+          updateValidAndValue(name, false, void 0, fieldRef);
+        } else {
+          field = get(_fields, name, {});
+          if (field._f) {
+            field._f.mount = false;
+          }
+          (_options.shouldUnregister || options2.shouldUnregister) && !(isNameInFieldArray(_names.array, name) && _state.action) && _names.unMount.add(name);
+        }
+      }
+    };
+  };
+  const _focusError = () => _options.shouldFocusError && iterateFieldsByAction(_fields, _focusInput, _names.mount);
+  const _disableForm = (disabled) => {
+    if (isBoolean(disabled)) {
+      _subjects.state.next({ disabled });
+      iterateFieldsByAction(_fields, (ref) => {
+        ref.disabled = disabled;
+      }, 0, false);
+    }
+  };
+  const handleSubmit = (onValid, onInvalid) => async (e) => {
+    if (e) {
+      e.preventDefault && e.preventDefault();
+      e.persist && e.persist();
+    }
+    let fieldValues = cloneObject(_formValues);
+    _subjects.state.next({
+      isSubmitting: true
+    });
+    if (_options.resolver) {
+      const { errors: errors2, values } = await _executeSchema();
+      _formState.errors = errors2;
+      fieldValues = values;
+    } else {
+      await executeBuiltInValidation(_fields);
+    }
+    unset(_formState.errors, "root");
+    if (isEmptyObject(_formState.errors)) {
+      _subjects.state.next({
+        errors: {}
+      });
+      await onValid(fieldValues, e);
+    } else {
+      if (onInvalid) {
+        await onInvalid({ ..._formState.errors }, e);
+      }
+      _focusError();
+      setTimeout(_focusError);
+    }
+    _subjects.state.next({
+      isSubmitted: true,
+      isSubmitting: false,
+      isSubmitSuccessful: isEmptyObject(_formState.errors),
+      submitCount: _formState.submitCount + 1,
+      errors: _formState.errors
+    });
+  };
+  const resetField = (name, options2 = {}) => {
+    if (get(_fields, name)) {
+      if (isUndefined(options2.defaultValue)) {
+        setValue(name, get(_defaultValues, name));
+      } else {
+        setValue(name, options2.defaultValue);
+        set(_defaultValues, name, options2.defaultValue);
+      }
+      if (!options2.keepTouched) {
+        unset(_formState.touchedFields, name);
+      }
+      if (!options2.keepDirty) {
+        unset(_formState.dirtyFields, name);
+        _formState.isDirty = options2.defaultValue ? _getDirty(name, get(_defaultValues, name)) : _getDirty();
+      }
+      if (!options2.keepError) {
+        unset(_formState.errors, name);
+        _proxyFormState.isValid && _updateValid();
+      }
+      _subjects.state.next({ ..._formState });
+    }
+  };
+  const _reset = (formValues, keepStateOptions = {}) => {
+    const updatedValues = formValues ? cloneObject(formValues) : _defaultValues;
+    const cloneUpdatedValues = cloneObject(updatedValues);
+    const values = formValues && !isEmptyObject(formValues) ? cloneUpdatedValues : _defaultValues;
+    if (!keepStateOptions.keepDefaultValues) {
+      _defaultValues = updatedValues;
+    }
+    if (!keepStateOptions.keepValues) {
+      if (keepStateOptions.keepDirtyValues || shouldCaptureDirtyFields) {
+        for (const fieldName of _names.mount) {
+          get(_formState.dirtyFields, fieldName) ? set(values, fieldName, get(_formValues, fieldName)) : setValue(fieldName, get(values, fieldName));
+        }
+      } else {
+        if (isWeb && isUndefined(formValues)) {
+          for (const name of _names.mount) {
+            const field = get(_fields, name);
+            if (field && field._f) {
+              const fieldReference = Array.isArray(field._f.refs) ? field._f.refs[0] : field._f.ref;
+              if (isHTMLElement(fieldReference)) {
+                const form = fieldReference.closest("form");
+                if (form) {
+                  form.reset();
+                  break;
+                }
+              }
+            }
+          }
+        }
+        _fields = {};
+      }
+      _formValues = props.shouldUnregister ? keepStateOptions.keepDefaultValues ? cloneObject(_defaultValues) : {} : cloneObject(values);
+      _subjects.array.next({
+        values: { ...values }
+      });
+      _subjects.values.next({
+        values: { ...values }
+      });
+    }
+    _names = {
+      mount: /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: false,
+      focus: ""
+    };
+    !_state.mount && flushRootRender();
+    _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid;
+    _state.watch = !!props.shouldUnregister;
+    _subjects.state.next({
+      submitCount: keepStateOptions.keepSubmitCount ? _formState.submitCount : 0,
+      isDirty: keepStateOptions.keepDirty ? _formState.isDirty : !!(keepStateOptions.keepDefaultValues && !deepEqual(formValues, _defaultValues)),
+      isSubmitted: keepStateOptions.keepIsSubmitted ? _formState.isSubmitted : false,
+      dirtyFields: keepStateOptions.keepDirtyValues ? _formState.dirtyFields : keepStateOptions.keepDefaultValues && formValues ? getDirtyFields(_defaultValues, formValues) : {},
+      touchedFields: keepStateOptions.keepTouched ? _formState.touchedFields : {},
+      errors: keepStateOptions.keepErrors ? _formState.errors : {},
+      isSubmitSuccessful: keepStateOptions.keepIsSubmitSuccessful ? _formState.isSubmitSuccessful : false,
+      isSubmitting: false
+    });
+  };
+  const reset = (formValues, keepStateOptions) => _reset(isFunction(formValues) ? formValues(_formValues) : formValues, keepStateOptions);
+  const setFocus = (name, options2 = {}) => {
+    const field = get(_fields, name);
+    const fieldReference = field && field._f;
+    if (fieldReference) {
+      const fieldRef = fieldReference.refs ? fieldReference.refs[0] : fieldReference.ref;
+      if (fieldRef.focus) {
+        fieldRef.focus();
+        options2.shouldSelect && fieldRef.select();
+      }
+    }
+  };
+  const _updateFormState = (updatedFormState) => {
+    _formState = {
+      ..._formState,
+      ...updatedFormState
+    };
+  };
+  const _resetDefaultValues = () => isFunction(_options.defaultValues) && _options.defaultValues().then((values) => {
+    reset(values, _options.resetOptions);
+    _subjects.state.next({
+      isLoading: false
+    });
+  });
+  return {
+    control: {
+      register,
+      unregister,
+      getFieldState,
+      handleSubmit,
+      setError,
+      _executeSchema,
+      _getWatch,
+      _getDirty,
+      _updateValid,
+      _removeUnmounted,
+      _updateFieldArray,
+      _updateDisabledField,
+      _getFieldArray,
+      _reset,
+      _resetDefaultValues,
+      _updateFormState,
+      _disableForm,
+      _subjects,
+      _proxyFormState,
+      get _fields() {
+        return _fields;
+      },
+      get _formValues() {
+        return _formValues;
+      },
+      get _state() {
+        return _state;
+      },
+      set _state(value) {
+        _state = value;
+      },
+      get _defaultValues() {
+        return _defaultValues;
+      },
+      get _names() {
+        return _names;
+      },
+      set _names(value) {
+        _names = value;
+      },
+      get _formState() {
+        return _formState;
+      },
+      set _formState(value) {
+        _formState = value;
+      },
+      get _options() {
+        return _options;
+      },
+      set _options(value) {
+        _options = {
+          ..._options,
+          ...value
+        };
+      }
+    },
+    trigger,
+    register,
+    handleSubmit,
+    watch,
+    setValue,
+    getValues,
+    reset,
+    resetField,
+    clearErrors,
+    unregister,
+    setError,
+    setFocus,
+    getFieldState
+  };
+}
+function useForm(props = {}) {
+  const _formControl = index.Cn.useRef();
+  const _values = index.Cn.useRef();
+  const [formState, updateFormState] = index.Cn.useState({
+    isDirty: false,
+    isValidating: false,
+    isLoading: isFunction(props.defaultValues),
+    isSubmitted: false,
+    isSubmitting: false,
+    isSubmitSuccessful: false,
+    isValid: false,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    errors: {},
+    disabled: false,
+    defaultValues: isFunction(props.defaultValues) ? void 0 : props.defaultValues
+  });
+  if (!_formControl.current) {
+    _formControl.current = {
+      ...createFormControl(props, () => updateFormState((formState2) => ({ ...formState2 }))),
+      formState
+    };
+  }
+  const control = _formControl.current.control;
+  control._options = props;
+  useSubscribe({
+    subject: control._subjects.state,
+    next: (value) => {
+      if (shouldRenderFormState(value, control._proxyFormState, control._updateFormState, true)) {
+        updateFormState({ ...control._formState });
+      }
+    }
+  });
+  index.Cn.useEffect(() => control._disableForm(props.disabled), [control, props.disabled]);
+  index.Cn.useEffect(() => {
+    if (control._proxyFormState.isDirty) {
+      const isDirty = control._getDirty();
+      if (isDirty !== formState.isDirty) {
+        control._subjects.state.next({
+          isDirty
+        });
+      }
+    }
+  }, [control, formState.isDirty]);
+  index.Cn.useEffect(() => {
+    if (props.values && !deepEqual(props.values, _values.current)) {
+      control._reset(props.values, control._options.resetOptions);
+      _values.current = props.values;
+    } else {
+      control._resetDefaultValues();
+    }
+  }, [props.values, control]);
+  index.Cn.useEffect(() => {
+    if (!control._state.mount) {
+      control._updateValid();
+      control._state.mount = true;
+    }
+    if (control._state.watch) {
+      control._state.watch = false;
+      control._subjects.state.next({ ...control._formState });
+    }
+    control._removeUnmounted();
+  });
+  _formControl.current.formState = getProxyFormState(formState, control);
+  return _formControl.current;
+}
+var t = function(e, t2, i2) {
+  if (e && "reportValidity" in e) {
+    var n2 = get(i2, t2);
+    e.setCustomValidity(n2 && n2.message || ""), e.reportValidity();
+  }
+}, i$1 = function(r, e) {
+  var i2 = function(i3) {
+    var n3 = e.fields[i3];
+    n3 && n3.ref && "reportValidity" in n3.ref ? t(n3.ref, i3, r) : n3.refs && n3.refs.forEach(function(e2) {
+      return t(e2, i3, r);
+    });
+  };
+  for (var n2 in e.fields)
+    i2(n2);
+}, n = function(t2, n2) {
+  n2.shouldUseNativeValidation && i$1(t2, n2);
+  var f = {};
+  for (var s in t2) {
+    var u = get(n2.fields, s), c = Object.assign(t2[s] || {}, { ref: u && u.ref });
+    if (a$1(n2.names || Object.keys(t2), s)) {
+      var l = Object.assign({}, o(get(f, s)));
+      set(l, "root", c), set(f, s, l);
+    } else
+      set(f, s, c);
+  }
+  return f;
+}, o = function(r) {
+  return Array.isArray(r) ? r.filter(Boolean) : [];
+}, a$1 = function(r, e) {
+  return r.some(function(r2) {
+    return r2.startsWith(e + ".");
+  });
+};
+var a = function(r, e) {
+  for (var t2 = {}; r.issues.length; ) {
+    var o2 = r.issues[0];
+    if (o2.path) {
+      var a2 = o2.path.map(function(r2) {
+        return r2.key;
+      }).join(".");
+      if (t2[a2] || (t2[a2] = { message: o2.message, type: o2.validation }), e) {
+        var i2 = t2[a2].types, s = i2 && i2[o2.validation];
+        t2[a2] = appendErrors(a2, e, t2, o2.validation, s ? [].concat(s, o2.message) : o2.message);
+      }
+      r.issues.shift();
+    }
+  }
+  return t2;
+}, i = function(n$1, i2, s) {
+  return void 0 === s && (s = {}), function(u, c, f) {
+    try {
+      return Promise.resolve(function(r, o2) {
+        try {
+          var a2 = function() {
+            function r2(r3) {
+              return { values: s.raw ? u : r3, errors: {} };
+            }
+            var o3 = Object.assign({}, { abortEarly: false, abortPipeEarly: false }, i2);
+            return "sync" === s.mode ? r2(index.parse(n$1, u, o3)) : Promise.resolve(index.parseAsync(n$1, u, o3)).then(r2);
+          }();
+        } catch (r2) {
+          return o2(r2);
+        }
+        return a2 && a2.then ? a2.then(void 0, o2) : a2;
+      }(0, function(e) {
+        if (e instanceof index.ValiError)
+          return { values: {}, errors: n(a(e, !f.shouldUseNativeValidation && "all" === f.criteriaMode), f) };
+        throw e;
+      }));
+    } catch (r) {
+      return Promise.reject(r);
+    }
+  };
+};
+const submitIfSingleChecked = (form) => {
+  const formObj = Object.fromEntries(new FormData(form).entries());
+  const isSingleChecked = Object.keys(formObj).length;
+  if (!isSingleChecked)
+    return;
+  form.dispatchEvent(new Event("submit", {
+    bubbles: true
+  }));
+};
+const isMultipleChoiceSubmission = index.isSubmissionOfType("multiple-choice");
+const getResolver$1 = (config) => {
+  const length = {
+    min: config.minSelected ?? 0,
+    max: config.maxSelected ?? config.options.length
+  };
+  return i(index.object({
+    checked: index.transform(index.record(index.boolean()), (o2) => Object.entries(o2).filter(([_, v]) => v).map(([k, _]) => k), [index.maxLength(length.max, `Please select at most ${length.max} option${length.max !== 1 ? "s" : ""}`), index.minLength(length.min, `Please select at least ${length.min} option${length.min !== 1 ? "s" : ""}`)])
+  }));
+};
+const ChatInputMultipleChoice = ({
+  input,
+  onSubmitSuccess,
+  onHeightChange
+}) => {
+  var _a, _b;
+  const submission = input.key ? (_a = index.application.current$.value.application) == null ? void 0 : _a.data.submissions[input.key] : void 0;
+  const {
+    register,
+    handleSubmit,
+    formState: {
+      errors: errors2
+    }
+  } = useForm({
+    defaultValues: {
+      checked: isMultipleChoiceSubmission(submission) ? Object.fromEntries(submission.value.map((key) => [key, true])) : {}
+    },
+    resolver: getResolver$1(input.config)
+  });
+  const focusRef = useFocusOnMount();
+  const isSingleChoice = input.config.minSelected === 1 && input.config.maxSelected === 1;
+  return index.o("form", {
+    noValidate: true,
+    class: "flex flex-col gap-1",
+    onChange: (e) => {
+      if (isSingleChoice) {
+        submitIfSingleChecked(e.currentTarget);
+      }
+    },
+    onSubmit: handleSubmit((submission2) => {
+      const checked = submission2.checked;
+      onSubmitSuccess(checked);
+    }),
+    children: [index.o("div", {
+      class: "flex items-center gap-2",
+      children: [index.o("div", {
+        class: index.clsx("flex w-full flex-1 flex-wrap gap-3 p-1", {
+          "justify-center": input.config.options.length === 1
+        }),
+        children: input.config.options.map((option, i2) => {
+          const id = `checked.${option.value}`;
+          const {
+            ref: setRef,
+            ...props
+          } = register(id);
+          return index.o("div", {
+            children: [index.o("input", {
+              autoFocus: i2 === 0,
+              ref: (e) => {
+                if (e && i2 === 0) {
+                  focusRef.current = e;
+                }
+                setRef(e);
+              },
+              id,
+              ...props,
+              class: "peer sr-only",
+              type: "checkbox"
+            }), index.o("label", {
+              class: "bg-lowest peer-focus-visible:ring-accent-7 active:outline-neutral-10 ease-expo-out outline-neutral-12/5 text-neutral-11 peer-checked:outline-accent-7 peer-checked:bg-accent-2 peer-checked:text-accent-9 block rounded-2xl px-2.5 py-1 outline outline-2 ring-0 ring-transparent transition-all duration-300 selection:bg-transparent peer-focus-visible:ring-4 peer-focus-visible:ring-offset-2",
+              htmlFor: id,
+              children: option.label
+            })]
+          }, option.value);
+        })
+      }), !isSingleChoice && index.o(SendButton, {})]
+    }), index.o(InputError, {
+      onAnimationComplete: onHeightChange,
+      error: (_b = errors2.checked) == null ? void 0 : _b.root
+    })]
+  });
+};
+const errors = {
+  email: "That doesn’t look like a valid email address",
+  phone: "That doesn’t look like a valid phone number"
+};
+const PhoneSchema = index.string(errors.phone, [index.regex(/^\+?[0-9 -]+$/, errors.phone)]);
+const inputFormatToSchema = {
+  email: index.string(errors.email, [index.email(errors.email)]),
+  phone: index.transform(PhoneSchema, (value) => value.replace(/[^0-9]/g, "")),
+  text: index.string([index.minLength(1, "Please enter some text")]),
+  url: index.string([index.url("That doesn’t look like a valid URL")])
+};
+const inputFormatToProps = {
+  email: {
+    type: "email",
+    inputMode: "email",
+    formNoValidate: true
+  },
+  phone: {
+    type: "tel",
+    inputMode: "tel"
+  },
+  text: {
+    type: "text",
+    inputMode: "text"
+  },
+  url: {
+    type: "url",
+    inputMode: "url",
+    formNoValidate: true
+  }
+};
+const isTextSubmission = index.isSubmissionOfType("text");
+const getResolver = (config) => i(index.object({
+  text: inputFormatToSchema[config.format]
+}));
+const ChatInputText = ({
+  input,
+  onSubmitSuccess,
+  onHeightChange
+}) => {
+  var _a;
+  const submission = input.key ? (_a = index.application.current$.value.application) == null ? void 0 : _a.data.submissions[input.key] : void 0;
+  const {
+    register,
+    handleSubmit,
+    formState: {
+      errors: errors2
+    }
+  } = useForm({
+    defaultValues: {
+      text: isTextSubmission(submission) ? submission.value : ""
+    },
+    resolver: getResolver(input.config)
+  });
+  const {
+    ref: setRef,
+    ...props
+  } = register("text", {
+    required: true
+  });
+  const ref = index._$1();
+  index.y(() => {
+    if (ref.current) {
+      ref.current.focus();
+      ref.current.select();
+    }
+  }, []);
+  return index.o("form", {
+    noValidate: true,
+    class: "flex flex-col gap-1",
+    onSubmit: handleSubmit((submission2) => {
+      onSubmitSuccess(submission2.text);
+    }),
+    children: [index.o("div", {
+      class: "flex items-center gap-2",
+      children: [index.o("input", {
+        id: "chat-input",
+        ...props,
+        ...inputFormatToProps[input.config.format],
+        autocomplete: "off",
+        autoCapitalize: "off",
+        autoCorrect: "off",
+        autoFocus: true,
+        ref: (e) => {
+          if (e) {
+            ref.current = e;
+          }
+          setRef(e);
+        },
+        class: "outline-neutral-12/5 ease-expo-out placeholder:text-neutral-5 focus-visible:outline-accent-7 caret-accent-9 flex-grow rounded-full px-3 py-1 text-base outline outline-2 transition-all duration-300",
+        placeholder: input.config.placeholder
+      }), index.o(SendButton, {})]
+    }), index.o(InputError, {
+      onAnimationComplete: onHeightChange,
+      error: errors2.text
+    })]
+  });
+};
+const ChatInput = ({
+  onSubmit,
+  onInputChange,
+  input
+}) => {
+  const inputWrapperRef = index._$1(null);
+  const updateHeight = index.T(() => {
+    if (inputWrapperRef.current) {
+      index.inputHeight.value = inputWrapperRef.current.getBoundingClientRect().height;
+    }
+  }, []);
+  index.p(() => {
+    updateHeight();
+    onInputChange(input == null ? void 0 : input.type);
+  }, [input == null ? void 0 : input.type, onInputChange, updateHeight]);
+  const handleSubmitSuccess = (type) => (value) => onSubmit({
+    type,
+    value
+  });
+  return index.o(framerMotion.m.div, {
+    initial: {
+      height: 0
+    },
+    animate: {
+      height: index.inputHeight.value
+    },
+    exit: {
+      height: 0,
+      opacity: 0
+    },
+    class: "bg-neutral-2/80 absolute bottom-0 w-full overflow-hidden rounded-b-3xl backdrop-blur-md backdrop-saturate-150",
+    children: index.o("div", {
+      ref: inputWrapperRef,
+      class: "border-neutral-12/5 border-t p-2.5",
+      children: index.N({
+        application: index.application,
+        input,
+        onHeightChange: updateHeight
+      }).with({
+        input: index._.nullish
+      }, () => index.o("div", {
+        class: "flex items-center gap-2",
+        children: [index.o("input", {
+          "aria-hidden": "true",
+          id: "chat-input",
+          class: "outline-neutral-12/5 placeholder:text-neutral-4 focus-visible:outline-accent-9 caret-accent-9 flex-grow rounded-full px-3 py-1 text-base outline outline-2",
+          disabled: true
+        }), index.o(SendButton, {
+          disabled: true,
+          "aria-hidden": "true",
+          tabIndex: -1
+        })]
+      })).with({
+        input: {
+          type: "text"
+        }
+      }, (props) => index.o(ChatInputText, {
+        onSubmitSuccess: handleSubmitSuccess(props.input.type),
+        ...props
+      })).with({
+        input: {
+          type: "multiple-choice"
+        }
+      }, (props) => index.o(ChatInputMultipleChoice, {
+        onSubmitSuccess: handleSubmitSuccess(props.input.type),
+        ...props
+      })).with({
+        input: {
+          type: "boolean"
+        }
+      }, (props) => index.o(ChatInputBoolean, {
+        onSubmitSuccess: handleSubmitSuccess(props.input.type),
+        ...props
+      })).with({
+        input: {
+          type: "file"
+        }
+      }, (props) => index.o(ChatInputFile, {
+        onSubmitSuccess: handleSubmitSuccess(props.input.type),
+        ...props
+      })).exhaustive()
+    })
+  });
+};
+const falsyToString = (value) => typeof value === "boolean" ? "".concat(value) : value === 0 ? "0" : value;
+const cx = index.clsx;
+const cva = (base, config) => {
+  return (props) => {
+    var ref;
+    if ((config === null || config === void 0 ? void 0 : config.variants) == null)
+      return cx(base, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+    const { variants, defaultVariants } = config;
+    const getVariantClassNames = Object.keys(variants).map((variant) => {
+      const variantProp = props === null || props === void 0 ? void 0 : props[variant];
+      const defaultVariantProp = defaultVariants === null || defaultVariants === void 0 ? void 0 : defaultVariants[variant];
+      if (variantProp === null)
+        return null;
+      const variantKey = falsyToString(variantProp) || falsyToString(defaultVariantProp);
+      return variants[variant][variantKey];
+    });
+    const propsWithoutUndefined = props && Object.entries(props).reduce((acc, param) => {
+      let [key, value] = param;
+      if (value === void 0) {
+        return acc;
+      }
+      acc[key] = value;
+      return acc;
+    }, {});
+    const getCompoundVariantClassNames = config === null || config === void 0 ? void 0 : (ref = config.compoundVariants) === null || ref === void 0 ? void 0 : ref.reduce((acc, param1) => {
+      let { class: cvClass, className: cvClassName, ...compoundVariantOptions } = param1;
+      return Object.entries(compoundVariantOptions).every((param) => {
+        let [key, value] = param;
+        return Array.isArray(value) ? value.includes({
+          ...defaultVariants,
+          ...propsWithoutUndefined
+        }[key]) : {
+          ...defaultVariants,
+          ...propsWithoutUndefined
+        }[key] === value;
+      }) ? [
+        ...acc,
+        cvClass,
+        cvClassName
+      ] : acc;
+    }, []);
+    return cx(base, getVariantClassNames, getCompoundVariantClassNames, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+  };
+};
+const chatBubbleVariants = cva("max-w-[min(100%,24rem)] [text-wrap:pretty] leading-snug flex-shrink-1 min-w-[2rem] text-md py-2 px-3 rounded-[18px] min-h-[36px] break-words", {
+  variants: {
+    side: {
+      left: "bg-lowest text-neutral-12 shadow-surface-sm outline outline-1 outline-neutral-11/[.08] rounded-bl-md",
+      right: "ml-auto bg-accent-7 text-lowest rounded-br-md bubble-right"
+    },
+    transitionState: {
+      entering: "opacity-0 translate-y-8",
+      entered: "opacity-100 translate-y-0",
+      exiting: "opacity-0 scale-0",
+      exited: ""
+    }
+  },
+  defaultVariants: {
+    side: "left"
+  }
+});
+const motionVariants = {
+  hidden: {
+    y: "100%",
+    scale: 0.75
+  },
+  shown: {
+    y: 0,
+    scale: 1
+  }
+};
+const ChatBubble = ({
+  children,
+  className,
+  transitionState,
+  side,
+  ...props
+}) => {
+  return index.o(framerMotion.m.p, {
+    variants: motionVariants,
+    initial: "hidden",
+    animate: "shown",
+    transition: {
+      type: "spring",
+      damping: 25,
+      stiffness: 500
+    },
+    "data-transition": transitionState,
+    style: {
+      transformOrigin: side === "left" ? "0% 50%" : "100% 50%"
+    },
+    class: chatBubbleVariants({
+      className,
+      side,
+      transitionState
+    }),
+    ...props,
+    children
+  });
+};
+const TypingIndicator = ({
+  className,
+  ...props
+}) => {
+  return index.o("div", {
+    class: index.clsx("flex gap-1 p-4", className),
+    ...props,
+    children: Array.from({
+      length: 3
+    }, (_, i2) => index.o("div", {
+      class: "bg-accent-7 h-1.5 w-1.5 animate-bounce rounded-full",
+      style: {
+        animationDelay: `${-i2 * 200}ms`
+      }
+    }))
+  });
+};
+const authorToSide = {
+  bot: "left",
+  user: "right"
+};
+const systemMessageStyle = cva("w-full select-none py-2 text-center text-[10px] uppercase tracking-widest drop-shadow-[0_1.5px_white]", {
+  variants: {
+    variant: {
+      info: "text-neutral-8",
+      warning: "text-[#FFC107]",
+      error: "text-error-9",
+      success: "text-[#4CAF50]"
+    }
+  }
+});
+const JobApplicationMessages = ({
+  messages,
+  isBotTyping
+}) => {
+  return index.o("ol", {
+    "aria-label": "Chat messages",
+    class: "flex flex-grow flex-col justify-end gap-2 p-2 pt-[calc(var(--header-height)+1rem)]",
+    children: [index.o(framerMotion.AnimatePresence, {
+      initial: false,
+      children: messages.map((message, i2) => index.o("li", {
+        class: "flex",
+        children: index.N(message).with({
+          type: "system"
+        }, (message2) => index.o("p", {
+          class: systemMessageStyle({
+            variant: message2.variant
+          }),
+          children: message2.text
+        })).with({
+          type: "text",
+          author: index._.union("bot", "user")
+        }, (message2) => {
+          return index.o(ChatBubble, {
+            side: authorToSide[message2.author],
+            children: message2.text
+          }, i2);
+        }).with({
+          type: "link"
+        }, (message2) => {
+          return index.o("div", {
+            class: "bg-accent-8/5 flex w-full items-center justify-center overflow-hidden rounded-xl py-2",
+            children: index.o("a", {
+              class: "bg-lowest shadow-surface-sm ring-accent-8/20 hover:ring-accent-8 active:bg-accent-2 active:text-accent-10 text-accent-9 focus-visible:ring-accent-7/50 flex items-center gap-1.5 truncate rounded-full py-2 pl-4 pr-2.5 no-underline ring-1 transition-all focus:outline-none focus-visible:ring-4 focus-visible:ring-offset-2",
+              target: "_blank",
+              href: message2.href,
+              children: [message2.text, index.o("svg", {
+                width: "15",
+                height: "15",
+                viewBox: "0 0 15 15",
+                fill: "none",
+                xmlns: "http://www.w3.org/2000/svg",
+                children: index.o("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"
+                })
+              })]
+            })
+          });
+        }).with({
+          type: "image"
+        }, (image) => index.o("img", {
+          class: "shadow-surface-md w-full max-w-[min(100%,24rem)] rounded-2xl",
+          src: image.url,
+          style: {
+            aspectRatio: image.width / image.height
+          }
+        })).with({
+          type: "file"
+        }, (file) => {
+          return index.o(FileThumbnail, {
+            class: file.author === "bot" ? "" : "ml-auto",
+            file: {
+              name: file.fileName,
+              sizeKb: file.fileSizeKb
+            }
+          });
+        }).exhaustive()
+      }, i2))
+    }), index.o("aside", {
+      "aria-hidden": true,
+      children: isBotTyping && index.o(TypingIndicator, {})
+    })]
+  });
+};
+const TYPING_SPEED_MS_PER_CHARACTER = 25;
+const useChatService = () => {
+  const chatRef = index._$1(null);
+  const [isBotTyping, setIsBotTyping] = index.h(false);
+  const [onSubmitSuccessFn, setOnSubmitSuccessFn] = index.h(() => () => {
+  });
+  const scrollToEnd = index.F(() => (options2) => {
+    var _a;
+    return (_a = chatRef.current) == null ? void 0 : _a.scrollTo({
+      top: chatRef.current.scrollHeight,
+      ...options2
+    });
+  }, [chatRef]);
+  const chatService = index.F(() => ({
+    send: async ({
+      message,
+      signal,
+      groupId
+    }) => {
+      await index.N(message).with({
+        author: "bot",
+        type: "text"
+      }, async (message2) => {
+        if (signal == null ? void 0 : signal.aborted)
+          throw new index.AbortedError();
+        setIsBotTyping(true);
+        const typingTime = Math.max(20, message2.text.length) * TYPING_SPEED_MS_PER_CHARACTER;
+        await new Promise((resolve) => {
+          return setTimeout(resolve, typingTime, {
+            signal
+          });
+        });
+        setIsBotTyping(false);
+      }).otherwise(async () => void 0);
+      if (signal == null ? void 0 : signal.aborted)
+        throw new index.AbortedError();
+      index.application.addMessage(message, groupId);
+    },
+    input: async ({
+      input,
+      signal
+    }) => {
+      if (signal == null ? void 0 : signal.aborted)
+        throw new index.AbortedError();
+      index.application.setInput(input);
+      return await new Promise((resolve) => {
+        const submitFunction = (submission) => {
+          if (signal == null ? void 0 : signal.aborted)
+            throw new index.AbortedError();
+          index.application.setInput(void 0);
+          if (input.key) {
+            index.application.setSubmission(input.key, submission);
+          }
+          resolve(submission);
+        };
+        setOnSubmitSuccessFn(() => submitFunction);
+      });
+    }
+  }), []);
+  return {
+    chatRef,
+    chatService,
+    isBotTyping,
+    onSubmitSuccessFn,
+    scrollToEnd
+  };
+};
+const JobApplicationContent = ({
+  currentApplication,
+  logger,
+  apiClient,
+  analytics
+}) => {
+  const {
+    chatRef,
+    chatService,
+    isBotTyping,
+    onSubmitSuccessFn,
+    scrollToEnd
+  } = useChatService();
+  const view = index.viewState.value;
+  const flow = currentApplication.flow;
+  const job = currentApplication.job;
+  index.y(() => {
+    if (view === "maximised")
+      scrollToEnd({
+        behavior: "instant"
+      });
+  }, [scrollToEnd, view]);
+  index.p(() => {
+    scrollToEnd({
+      behavior: "smooth"
+    });
+  }, [currentApplication.data.messages, scrollToEnd]);
+  index.y(() => {
+    const {
+      state,
+      application: currentApplication2
+    } = index.application.current$.peek();
+    if (state !== "loaded")
+      throw new Error(index.ERROR_MESSAGES.invalid_state);
+    const fromNodeId = currentApplication2.data.currentNodeId;
+    scrollToEnd({
+      behavior: "instant"
+    });
+    index.application.setInput(void 0);
+    if (currentApplication2.data.isFinished)
+      return;
+    const fromBeginning = currentApplication2.data.messages.length === 0;
+    if (fromBeginning) {
+      analytics.log({
+        event: "APPLY_START",
+        properties: {
+          job_id: job.id
+        },
+        customProperties: {
+          flow_id: flow.id
+        }
+      });
+    }
+    index.application.removeLastGroupMessagesById(fromNodeId);
+    const {
+      interpret: interpret2,
+      abort
+    } = createFlowInterpreter({
+      context: {
+        jobId: job.id,
+        flowId: flow.id
+      },
+      analytics,
+      apiClient,
+      logger,
+      flow: flow.nodes,
+      chatService,
+      // We need to get fresh submissions, that’s why we call `peek` here.
+      getSubmissions: () => {
+        var _a;
+        return (_a = index.application.current$.peek().application) == null ? void 0 : _a.data.submissions;
+      },
+      onInterpret: (node, prevNode) => {
+        analytics.log({
+          event: "FLOW_NODE",
+          properties: {
+            flow_id: flow.id,
+            flow_version: flow.version,
+            job_id: job.id,
+            from_node_id: prevNode ? prevNode.id : null,
+            to_node_id: node.id,
+            sequence: 1
+          }
+        });
+        index.application.setCurrentNodeId(node.id);
+      },
+      onFlowEnd: async () => {
+        index.application.markAsFinished();
+      }
+    });
+    interpret2(fromNodeId);
+    return abort;
+  }, [analytics, apiClient, chatService, logger, scrollToEnd, flow, job.id, currentApplication.startedAt]);
+  return index.o(index.k, {
+    children: [index.o("div", {
+      ref: chatRef,
+      className: "hide-scrollbars relative flex max-w-full flex-grow flex-col overflow-y-scroll",
+      style: {
+        WebkitOverflowScrolling: "touch",
+        paddingBottom: index.inputHeight.value
+      },
+      children: index.o(framerMotion.AnimatePresence, {
+        children: index.o(JobApplicationMessages, {
+          isBotTyping,
+          messages: currentApplication.data.messages
+        })
+      })
+    }), index.o(ChatInput, {
+      input: currentApplication.data.currentInput,
+      onInputChange: () => scrollToEnd({
+        behavior: "smooth"
+      }),
+      onSubmit: onSubmitSuccessFn
+    })]
+  });
+};
+exports.JobApplicationContent = JobApplicationContent;