@bookinglab/booking-ui-react 1.10.0 → 1.11.0

package/dist/index.js

@@ -3,7 +3,9 @@
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 
-// src/components/BookingForm.tsx
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var cx = (...classes) => classes.filter(Boolean).join(" ");
 function FormField({
   question,
@@ -35,7 +37,13 @@ function FormField({
   };
   const renderHelpText = () => {
     if (!question.help_text) return null;
-    return /* @__PURE__ */ jsxRuntime.jsx("p", { className: classNames?.helpText ?? defaultHelpText, children: question.help_text });
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "p",
+      {
+        className: classNames?.helpText ?? defaultHelpText,
+        dangerouslySetInnerHTML: { __html: question.help_text }
+      }
+    );
   };
   const renderError = () => {
     if (!error) return null;
@@ -105,6 +113,39 @@ function FormField({
         renderHelpText(),
         renderError()
       ] });
+    case "radio":
+      return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.fieldWrapper ?? defaultFieldWrapper, children: [
+        renderLabel(),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            role: "radiogroup",
+            "aria-labelledby": inputId,
+            className: classNames?.radioGroup ?? "flex flex-col gap-2 mt-1",
+            children: question.options?.map((option) => {
+              const optionId = `${inputId}-${option.id}`;
+              return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "input",
+                  {
+                    id: optionId,
+                    type: "radio",
+                    name: inputId,
+                    value: option.id,
+                    checked: String(value ?? "") === String(option.id),
+                    onChange: () => onChange(option.id),
+                    className: classNames?.radio ?? "h-4 w-4 border-gray-300 text-blue-600 focus:ring-blue-500",
+                    ...ariaProps
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: optionId, className: classNames?.radioLabel ?? cx("text-sm", classNames?.label ?? "text-gray-700"), children: option.name })
+              ] }, option.id);
+            })
+          }
+        ),
+        renderHelpText(),
+        renderError()
+      ] });
     case "date":
       return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.fieldWrapper ?? defaultFieldWrapper, children: [
         renderLabel(),
@@ -174,6 +215,7 @@ function BookingForm({
   questions,
   onSubmit,
   submitLabel = "Submit",
+  isAdmin = false,
   className = "",
   labelClassName,
   classNames: classNamesProp
@@ -247,7 +289,7 @@ function BookingForm({
     },
     [values, questions]
   );
-  const visibleQuestions = questions.filter(isQuestionVisible);
+  const visibleQuestions = questions.filter((q) => isAdmin || !q.admin_only).filter(isQuestionVisible);
   const validateField = react.useCallback((question, value) => {
     if (question.detail_type === "heading") return null;
     if (question.required) {
@@ -271,16 +313,16 @@ function BookingForm({
   }, []);
   const validateAll = react.useCallback(() => {
     const newErrors = {};
-    let isValid = true;
+    let isValid2 = true;
     visibleQuestions.forEach((question) => {
       const error = validateField(question, values[question.id]);
       if (error) {
         newErrors[question.id] = error;
-        isValid = false;
+        isValid2 = false;
       }
     });
     setErrors(newErrors);
-    return isValid;
+    return isValid2;
   }, [visibleQuestions, values, validateField]);
   react.useEffect(() => {
     const visibleIds = new Set(visibleQuestions.map((q) => q.id));
@@ -542,17 +584,17 @@ var RegistrationForm = react.forwardRef(
     );
     const validateAll = react.useCallback(() => {
       const newErrors = {};
-      let isValid = true;
+      let isValid2 = true;
       for (const field of allFields) {
         const value = values[field.name] || "";
         const error = validateField(field, value, values);
         if (error) {
           newErrors[field.name] = error;
-          isValid = false;
+          isValid2 = false;
         }
       }
       setErrors(newErrors);
-      return isValid;
+      return isValid2;
     }, [allFields, values, validateField]);
     const checkIsValid = react.useCallback(
       (currentValues) => {
@@ -613,8 +655,8 @@ var RegistrationForm = react.forwardRef(
           }
         }
         if (onChange) {
-          const isValid = checkIsValid(newValues);
-          onChange(newValues, isValid);
+          const isValid2 = checkIsValid(newValues);
+          onChange(newValues, isValid2);
         }
       },
       [values, touched, allFields, validateField, onChange, checkIsValid]
@@ -1319,18 +1361,18 @@ var ResetPasswordForm = react.forwardRef(
         e.preventDefault();
         const allTouched = {};
         const newErrors = {};
-        let isValid = true;
+        let isValid2 = true;
         for (const field of FIELDS) {
           allTouched[field.name] = true;
           const error = validateField(field.name, values[field.name], values);
           if (error) {
             newErrors[field.name] = error;
-            isValid = false;
+            isValid2 = false;
           }
         }
         setTouched(allTouched);
         setErrors(newErrors);
-        if (isValid) {
+        if (isValid2) {
           onSubmit(values);
           setValues({ currentPassword: "", newPassword: "", confirmNewPassword: "" });
           setErrors({});
@@ -1402,12 +1444,4245 @@ var ResetPasswordForm = react.forwardRef(
 );
 ResetPasswordForm.displayName = "ResetPasswordForm";
 
+// ../../node_modules/date-fns/toDate.mjs
+function toDate(argument) {
+  const argStr = Object.prototype.toString.call(argument);
+  if (argument instanceof Date || typeof argument === "object" && argStr === "[object Date]") {
+    return new argument.constructor(+argument);
+  } else if (typeof argument === "number" || argStr === "[object Number]" || typeof argument === "string" || argStr === "[object String]") {
+    return new Date(argument);
+  } else {
+    return /* @__PURE__ */ new Date(NaN);
+  }
+}
+
+// ../../node_modules/date-fns/constructFrom.mjs
+function constructFrom(date, value) {
+  if (date instanceof Date) {
+    return new date.constructor(value);
+  } else {
+    return new Date(value);
+  }
+}
+
+// ../../node_modules/date-fns/addDays.mjs
+function addDays(date, amount) {
+  const _date = toDate(date);
+  if (isNaN(amount)) return constructFrom(date, NaN);
+  if (!amount) {
+    return _date;
+  }
+  _date.setDate(_date.getDate() + amount);
+  return _date;
+}
+var millisecondsInWeek = 6048e5;
+var millisecondsInMinute = 6e4;
+var millisecondsInHour = 36e5;
+var millisecondsInSecond = 1e3;
+
+// ../../node_modules/date-fns/_lib/defaultOptions.mjs
+var defaultOptions = {};
+function getDefaultOptions() {
+  return defaultOptions;
+}
+
+// ../../node_modules/date-fns/startOfWeek.mjs
+function startOfWeek(date, options) {
+  const defaultOptions2 = getDefaultOptions();
+  const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
+  const _date = toDate(date);
+  const day = _date.getDay();
+  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  _date.setDate(_date.getDate() - diff);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+
+// ../../node_modules/date-fns/startOfISOWeek.mjs
+function startOfISOWeek(date) {
+  return startOfWeek(date, { weekStartsOn: 1 });
+}
+
+// ../../node_modules/date-fns/getISOWeekYear.mjs
+function getISOWeekYear(date) {
+  const _date = toDate(date);
+  const year = _date.getFullYear();
+  const fourthOfJanuaryOfNextYear = constructFrom(date, 0);
+  fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
+  fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
+  const startOfNextYear = startOfISOWeek(fourthOfJanuaryOfNextYear);
+  const fourthOfJanuaryOfThisYear = constructFrom(date, 0);
+  fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
+  fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
+  const startOfThisYear = startOfISOWeek(fourthOfJanuaryOfThisYear);
+  if (_date.getTime() >= startOfNextYear.getTime()) {
+    return year + 1;
+  } else if (_date.getTime() >= startOfThisYear.getTime()) {
+    return year;
+  } else {
+    return year - 1;
+  }
+}
+
+// ../../node_modules/date-fns/startOfDay.mjs
+function startOfDay(date) {
+  const _date = toDate(date);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+
+// ../../node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.mjs
+function getTimezoneOffsetInMilliseconds(date) {
+  const _date = toDate(date);
+  const utcDate = new Date(
+    Date.UTC(
+      _date.getFullYear(),
+      _date.getMonth(),
+      _date.getDate(),
+      _date.getHours(),
+      _date.getMinutes(),
+      _date.getSeconds(),
+      _date.getMilliseconds()
+    )
+  );
+  utcDate.setUTCFullYear(_date.getFullYear());
+  return +date - +utcDate;
+}
+
+// ../../node_modules/date-fns/startOfISOWeekYear.mjs
+function startOfISOWeekYear(date) {
+  const year = getISOWeekYear(date);
+  const fourthOfJanuary = constructFrom(date, 0);
+  fourthOfJanuary.setFullYear(year, 0, 4);
+  fourthOfJanuary.setHours(0, 0, 0, 0);
+  return startOfISOWeek(fourthOfJanuary);
+}
+
+// ../../node_modules/date-fns/isDate.mjs
+function isDate(value) {
+  return value instanceof Date || typeof value === "object" && Object.prototype.toString.call(value) === "[object Date]";
+}
+
+// ../../node_modules/date-fns/isValid.mjs
+function isValid(date) {
+  if (!isDate(date) && typeof date !== "number") {
+    return false;
+  }
+  const _date = toDate(date);
+  return !isNaN(Number(_date));
+}
+
+// ../../node_modules/date-fns/locale/en-US/_lib/formatDistance.mjs
+var formatDistanceLocale = {
+  lessThanXSeconds: {
+    one: "less than a second",
+    other: "less than {{count}} seconds"
+  },
+  xSeconds: {
+    one: "1 second",
+    other: "{{count}} seconds"
+  },
+  halfAMinute: "half a minute",
+  lessThanXMinutes: {
+    one: "less than a minute",
+    other: "less than {{count}} minutes"
+  },
+  xMinutes: {
+    one: "1 minute",
+    other: "{{count}} minutes"
+  },
+  aboutXHours: {
+    one: "about 1 hour",
+    other: "about {{count}} hours"
+  },
+  xHours: {
+    one: "1 hour",
+    other: "{{count}} hours"
+  },
+  xDays: {
+    one: "1 day",
+    other: "{{count}} days"
+  },
+  aboutXWeeks: {
+    one: "about 1 week",
+    other: "about {{count}} weeks"
+  },
+  xWeeks: {
+    one: "1 week",
+    other: "{{count}} weeks"
+  },
+  aboutXMonths: {
+    one: "about 1 month",
+    other: "about {{count}} months"
+  },
+  xMonths: {
+    one: "1 month",
+    other: "{{count}} months"
+  },
+  aboutXYears: {
+    one: "about 1 year",
+    other: "about {{count}} years"
+  },
+  xYears: {
+    one: "1 year",
+    other: "{{count}} years"
+  },
+  overXYears: {
+    one: "over 1 year",
+    other: "over {{count}} years"
+  },
+  almostXYears: {
+    one: "almost 1 year",
+    other: "almost {{count}} years"
+  }
+};
+var formatDistance = (token, count, options) => {
+  let result;
+  const tokenValue = formatDistanceLocale[token];
+  if (typeof tokenValue === "string") {
+    result = tokenValue;
+  } else if (count === 1) {
+    result = tokenValue.one;
+  } else {
+    result = tokenValue.other.replace("{{count}}", count.toString());
+  }
+  if (options?.addSuffix) {
+    if (options.comparison && options.comparison > 0) {
+      return "in " + result;
+    } else {
+      return result + " ago";
+    }
+  }
+  return result;
+};
+
+// ../../node_modules/date-fns/locale/_lib/buildFormatLongFn.mjs
+function buildFormatLongFn(args) {
+  return (options = {}) => {
+    const width = options.width ? String(options.width) : args.defaultWidth;
+    const format = args.formats[width] || args.formats[args.defaultWidth];
+    return format;
+  };
+}
+
+// ../../node_modules/date-fns/locale/en-US/_lib/formatLong.mjs
+var dateFormats = {
+  full: "EEEE, MMMM do, y",
+  long: "MMMM do, y",
+  medium: "MMM d, y",
+  short: "MM/dd/yyyy"
+};
+var timeFormats = {
+  full: "h:mm:ss a zzzz",
+  long: "h:mm:ss a z",
+  medium: "h:mm:ss a",
+  short: "h:mm a"
+};
+var dateTimeFormats = {
+  full: "{{date}} 'at' {{time}}",
+  long: "{{date}} 'at' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+};
+var formatLong = {
+  date: buildFormatLongFn({
+    formats: dateFormats,
+    defaultWidth: "full"
+  }),
+  time: buildFormatLongFn({
+    formats: timeFormats,
+    defaultWidth: "full"
+  }),
+  dateTime: buildFormatLongFn({
+    formats: dateTimeFormats,
+    defaultWidth: "full"
+  })
+};
+
+// ../../node_modules/date-fns/locale/en-US/_lib/formatRelative.mjs
+var formatRelativeLocale = {
+  lastWeek: "'last' eeee 'at' p",
+  yesterday: "'yesterday at' p",
+  today: "'today at' p",
+  tomorrow: "'tomorrow at' p",
+  nextWeek: "eeee 'at' p",
+  other: "P"
+};
+var formatRelative = (token, _date, _baseDate, _options) => formatRelativeLocale[token];
+
+// ../../node_modules/date-fns/locale/_lib/buildLocalizeFn.mjs
+function buildLocalizeFn(args) {
+  return (value, options) => {
+    const context = options?.context ? String(options.context) : "standalone";
+    let valuesArray;
+    if (context === "formatting" && args.formattingValues) {
+      const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+      const width = options?.width ? String(options.width) : defaultWidth;
+      valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
+    } else {
+      const defaultWidth = args.defaultWidth;
+      const width = options?.width ? String(options.width) : args.defaultWidth;
+      valuesArray = args.values[width] || args.values[defaultWidth];
+    }
+    const index = args.argumentCallback ? args.argumentCallback(value) : value;
+    return valuesArray[index];
+  };
+}
+
+// ../../node_modules/date-fns/locale/en-US/_lib/localize.mjs
+var eraValues = {
+  narrow: ["B", "A"],
+  abbreviated: ["BC", "AD"],
+  wide: ["Before Christ", "Anno Domini"]
+};
+var quarterValues = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
+  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
+};
+var monthValues = {
+  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
+  abbreviated: [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ],
+  wide: [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ]
+};
+var dayValues = {
+  narrow: ["S", "M", "T", "W", "T", "F", "S"],
+  short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+  abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+  wide: [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday"
+  ]
+};
+var dayPeriodValues = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  }
+};
+var formattingDayPeriodValues = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  }
+};
+var ordinalNumber = (dirtyNumber, _options) => {
+  const number = Number(dirtyNumber);
+  const rem100 = number % 100;
+  if (rem100 > 20 || rem100 < 10) {
+    switch (rem100 % 10) {
+      case 1:
+        return number + "st";
+      case 2:
+        return number + "nd";
+      case 3:
+        return number + "rd";
+    }
+  }
+  return number + "th";
+};
+var localize = {
+  ordinalNumber,
+  era: buildLocalizeFn({
+    values: eraValues,
+    defaultWidth: "wide"
+  }),
+  quarter: buildLocalizeFn({
+    values: quarterValues,
+    defaultWidth: "wide",
+    argumentCallback: (quarter) => quarter - 1
+  }),
+  month: buildLocalizeFn({
+    values: monthValues,
+    defaultWidth: "wide"
+  }),
+  day: buildLocalizeFn({
+    values: dayValues,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: buildLocalizeFn({
+    values: dayPeriodValues,
+    defaultWidth: "wide",
+    formattingValues: formattingDayPeriodValues,
+    defaultFormattingWidth: "wide"
+  })
+};
+
+// ../../node_modules/date-fns/locale/_lib/buildMatchFn.mjs
+function buildMatchFn(args) {
+  return (string, options = {}) => {
+    const width = options.width;
+    const matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
+    const matchResult = string.match(matchPattern);
+    if (!matchResult) {
+      return null;
+    }
+    const matchedString = matchResult[0];
+    const parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
+    const key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString)) : (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
+      findKey(parsePatterns, (pattern) => pattern.test(matchedString))
+    );
+    let value;
+    value = args.valueCallback ? args.valueCallback(key) : key;
+    value = options.valueCallback ? (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
+      options.valueCallback(value)
+    ) : value;
+    const rest = string.slice(matchedString.length);
+    return { value, rest };
+  };
+}
+function findKey(object, predicate) {
+  for (const key in object) {
+    if (Object.prototype.hasOwnProperty.call(object, key) && predicate(object[key])) {
+      return key;
+    }
+  }
+  return void 0;
+}
+function findIndex(array, predicate) {
+  for (let key = 0; key < array.length; key++) {
+    if (predicate(array[key])) {
+      return key;
+    }
+  }
+  return void 0;
+}
+
+// ../../node_modules/date-fns/locale/_lib/buildMatchPatternFn.mjs
+function buildMatchPatternFn(args) {
+  return (string, options = {}) => {
+    const matchResult = string.match(args.matchPattern);
+    if (!matchResult) return null;
+    const matchedString = matchResult[0];
+    const parseResult = string.match(args.parsePattern);
+    if (!parseResult) return null;
+    let value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
+    value = options.valueCallback ? options.valueCallback(value) : value;
+    const rest = string.slice(matchedString.length);
+    return { value, rest };
+  };
+}
+
+// ../../node_modules/date-fns/locale/en-US/_lib/match.mjs
+var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
+var parseOrdinalNumberPattern = /\d+/i;
+var matchEraPatterns = {
+  narrow: /^(b|a)/i,
+  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
+  wide: /^(before christ|before common era|anno domini|common era)/i
+};
+var parseEraPatterns = {
+  any: [/^b/i, /^(a|c)/i]
+};
+var matchQuarterPatterns = {
+  narrow: /^[1234]/i,
+  abbreviated: /^q[1234]/i,
+  wide: /^[1234](th|st|nd|rd)? quarter/i
+};
+var parseQuarterPatterns = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+};
+var matchMonthPatterns = {
+  narrow: /^[jfmasond]/i,
+  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
+};
+var parseMonthPatterns = {
+  narrow: [
+    /^j/i,
+    /^f/i,
+    /^m/i,
+    /^a/i,
+    /^m/i,
+    /^j/i,
+    /^j/i,
+    /^a/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ],
+  any: [
+    /^ja/i,
+    /^f/i,
+    /^mar/i,
+    /^ap/i,
+    /^may/i,
+    /^jun/i,
+    /^jul/i,
+    /^au/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ]
+};
+var matchDayPatterns = {
+  narrow: /^[smtwf]/i,
+  short: /^(su|mo|tu|we|th|fr|sa)/i,
+  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+};
+var parseDayPatterns = {
+  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
+  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+};
+var matchDayPeriodPatterns = {
+  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
+  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
+};
+var parseDayPeriodPatterns = {
+  any: {
+    am: /^a/i,
+    pm: /^p/i,
+    midnight: /^mi/i,
+    noon: /^no/i,
+    morning: /morning/i,
+    afternoon: /afternoon/i,
+    evening: /evening/i,
+    night: /night/i
+  }
+};
+var match = {
+  ordinalNumber: buildMatchPatternFn({
+    matchPattern: matchOrdinalNumberPattern,
+    parsePattern: parseOrdinalNumberPattern,
+    valueCallback: (value) => parseInt(value, 10)
+  }),
+  era: buildMatchFn({
+    matchPatterns: matchEraPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseEraPatterns,
+    defaultParseWidth: "any"
+  }),
+  quarter: buildMatchFn({
+    matchPatterns: matchQuarterPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseQuarterPatterns,
+    defaultParseWidth: "any",
+    valueCallback: (index) => index + 1
+  }),
+  month: buildMatchFn({
+    matchPatterns: matchMonthPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseMonthPatterns,
+    defaultParseWidth: "any"
+  }),
+  day: buildMatchFn({
+    matchPatterns: matchDayPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseDayPatterns,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: buildMatchFn({
+    matchPatterns: matchDayPeriodPatterns,
+    defaultMatchWidth: "any",
+    parsePatterns: parseDayPeriodPatterns,
+    defaultParseWidth: "any"
+  })
+};
+
+// ../../node_modules/date-fns/locale/en-US.mjs
+var enUS = {
+  code: "en-US",
+  formatDistance,
+  formatLong,
+  formatRelative,
+  localize,
+  match,
+  options: {
+    weekStartsOn: 0,
+    firstWeekContainsDate: 1
+  }
+};
+
+// ../../node_modules/date-fns/getISOWeek.mjs
+function getISOWeek(date) {
+  const _date = toDate(date);
+  const diff = +startOfISOWeek(_date) - +startOfISOWeekYear(_date);
+  return Math.round(diff / millisecondsInWeek) + 1;
+}
+
+// ../../node_modules/date-fns/getWeekYear.mjs
+function getWeekYear(date, options) {
+  const _date = toDate(date);
+  const year = _date.getFullYear();
+  const defaultOptions2 = getDefaultOptions();
+  const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
+  const firstWeekOfNextYear = constructFrom(date, 0);
+  firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
+  firstWeekOfNextYear.setHours(0, 0, 0, 0);
+  const startOfNextYear = startOfWeek(firstWeekOfNextYear, options);
+  const firstWeekOfThisYear = constructFrom(date, 0);
+  firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);
+  firstWeekOfThisYear.setHours(0, 0, 0, 0);
+  const startOfThisYear = startOfWeek(firstWeekOfThisYear, options);
+  if (_date.getTime() >= startOfNextYear.getTime()) {
+    return year + 1;
+  } else if (_date.getTime() >= startOfThisYear.getTime()) {
+    return year;
+  } else {
+    return year - 1;
+  }
+}
+
+// ../../node_modules/date-fns/startOfWeekYear.mjs
+function startOfWeekYear(date, options) {
+  const defaultOptions2 = getDefaultOptions();
+  const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
+  const year = getWeekYear(date, options);
+  const firstWeek = constructFrom(date, 0);
+  firstWeek.setFullYear(year, 0, firstWeekContainsDate);
+  firstWeek.setHours(0, 0, 0, 0);
+  const _date = startOfWeek(firstWeek, options);
+  return _date;
+}
+
+// ../../node_modules/date-fns/getWeek.mjs
+function getWeek(date, options) {
+  const _date = toDate(date);
+  const diff = +startOfWeek(_date, options) - +startOfWeekYear(_date, options);
+  return Math.round(diff / millisecondsInWeek) + 1;
+}
+
+// ../../node_modules/date-fns/_lib/format/longFormatters.mjs
+var dateLongFormatter = (pattern, formatLong2) => {
+  switch (pattern) {
+    case "P":
+      return formatLong2.date({ width: "short" });
+    case "PP":
+      return formatLong2.date({ width: "medium" });
+    case "PPP":
+      return formatLong2.date({ width: "long" });
+    case "PPPP":
+    default:
+      return formatLong2.date({ width: "full" });
+  }
+};
+var timeLongFormatter = (pattern, formatLong2) => {
+  switch (pattern) {
+    case "p":
+      return formatLong2.time({ width: "short" });
+    case "pp":
+      return formatLong2.time({ width: "medium" });
+    case "ppp":
+      return formatLong2.time({ width: "long" });
+    case "pppp":
+    default:
+      return formatLong2.time({ width: "full" });
+  }
+};
+var dateTimeLongFormatter = (pattern, formatLong2) => {
+  const matchResult = pattern.match(/(P+)(p+)?/) || [];
+  const datePattern = matchResult[1];
+  const timePattern = matchResult[2];
+  if (!timePattern) {
+    return dateLongFormatter(pattern, formatLong2);
+  }
+  let dateTimeFormat;
+  switch (datePattern) {
+    case "P":
+      dateTimeFormat = formatLong2.dateTime({ width: "short" });
+      break;
+    case "PP":
+      dateTimeFormat = formatLong2.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      dateTimeFormat = formatLong2.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      dateTimeFormat = formatLong2.dateTime({ width: "full" });
+      break;
+  }
+  return dateTimeFormat.replace("{{date}}", dateLongFormatter(datePattern, formatLong2)).replace("{{time}}", timeLongFormatter(timePattern, formatLong2));
+};
+var longFormatters = {
+  p: timeLongFormatter,
+  P: dateTimeLongFormatter
+};
+
+// ../../node_modules/date-fns/_lib/protectedTokens.mjs
+var dayOfYearTokenRE = /^D+$/;
+var weekYearTokenRE = /^Y+$/;
+var throwTokens = ["D", "DD", "YY", "YYYY"];
+function isProtectedDayOfYearToken(token) {
+  return dayOfYearTokenRE.test(token);
+}
+function isProtectedWeekYearToken(token) {
+  return weekYearTokenRE.test(token);
+}
+function warnOrThrowProtectedError(token, format, input) {
+  const _message = message(token, format, input);
+  console.warn(_message);
+  if (throwTokens.includes(token)) throw new RangeError(_message);
+}
+function message(token, format, input) {
+  const subject = token[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}
+
+// ../../node_modules/date-fns/getDefaultOptions.mjs
+function getDefaultOptions2() {
+  return Object.assign({}, getDefaultOptions());
+}
+
+// ../../node_modules/date-fns/getISODay.mjs
+function getISODay(date) {
+  const _date = toDate(date);
+  let day = _date.getDay();
+  if (day === 0) {
+    day = 7;
+  }
+  return day;
+}
+
+// ../../node_modules/date-fns/isAfter.mjs
+function isAfter(date, dateToCompare) {
+  const _date = toDate(date);
+  const _dateToCompare = toDate(dateToCompare);
+  return _date.getTime() > _dateToCompare.getTime();
+}
+
+// ../../node_modules/date-fns/isBefore.mjs
+function isBefore(date, dateToCompare) {
+  const _date = toDate(date);
+  const _dateToCompare = toDate(dateToCompare);
+  return +_date < +_dateToCompare;
+}
+
+// ../../node_modules/date-fns/transpose.mjs
+function transpose(fromDate, constructor) {
+  const date = constructor instanceof Date ? constructFrom(constructor, 0) : new constructor(0);
+  date.setFullYear(
+    fromDate.getFullYear(),
+    fromDate.getMonth(),
+    fromDate.getDate()
+  );
+  date.setHours(
+    fromDate.getHours(),
+    fromDate.getMinutes(),
+    fromDate.getSeconds(),
+    fromDate.getMilliseconds()
+  );
+  return date;
+}
+
+// ../../node_modules/date-fns/parse/_lib/Setter.mjs
+var TIMEZONE_UNIT_PRIORITY = 10;
+var Setter = class {
+  constructor() {
+    __publicField(this, "subPriority", 0);
+  }
+  validate(_utcDate, _options) {
+    return true;
+  }
+};
+var ValueSetter = class extends Setter {
+  constructor(value, validateValue, setValue, priority, subPriority) {
+    super();
+    this.value = value;
+    this.validateValue = validateValue;
+    this.setValue = setValue;
+    this.priority = priority;
+    if (subPriority) {
+      this.subPriority = subPriority;
+    }
+  }
+  validate(date, options) {
+    return this.validateValue(date, this.value, options);
+  }
+  set(date, flags, options) {
+    return this.setValue(date, flags, this.value, options);
+  }
+};
+var DateToSystemTimezoneSetter = class extends Setter {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", TIMEZONE_UNIT_PRIORITY);
+    __publicField(this, "subPriority", -1);
+  }
+  set(date, flags) {
+    if (flags.timestampIsSet) return date;
+    return constructFrom(date, transpose(date, Date));
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/Parser.mjs
+var Parser = class {
+  run(dateString, token, match2, options) {
+    const result = this.parse(dateString, token, match2, options);
+    if (!result) {
+      return null;
+    }
+    return {
+      setter: new ValueSetter(
+        result.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority
+      ),
+      rest: result.rest
+    };
+  }
+  validate(_utcDate, _value, _options) {
+    return true;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/EraParser.mjs
+var EraParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 140);
+    __publicField(this, "incompatibleTokens", ["R", "u", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return match2.era(dateString, { width: "abbreviated" }) || match2.era(dateString, { width: "narrow" });
+      // A, B
+      case "GGGGG":
+        return match2.era(dateString, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return match2.era(dateString, { width: "wide" }) || match2.era(dateString, { width: "abbreviated" }) || match2.era(dateString, { width: "narrow" });
+    }
+  }
+  set(date, flags, value) {
+    flags.era = value;
+    date.setFullYear(value, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/constants.mjs
+var numericPatterns = {
+  month: /^(1[0-2]|0?\d)/,
+  // 0 to 12
+  date: /^(3[0-1]|[0-2]?\d)/,
+  // 0 to 31
+  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
+  // 0 to 366
+  week: /^(5[0-3]|[0-4]?\d)/,
+  // 0 to 53
+  hour23h: /^(2[0-3]|[0-1]?\d)/,
+  // 0 to 23
+  hour24h: /^(2[0-4]|[0-1]?\d)/,
+  // 0 to 24
+  hour11h: /^(1[0-1]|0?\d)/,
+  // 0 to 11
+  hour12h: /^(1[0-2]|0?\d)/,
+  // 0 to 12
+  minute: /^[0-5]?\d/,
+  // 0 to 59
+  second: /^[0-5]?\d/,
+  // 0 to 59
+  singleDigit: /^\d/,
+  // 0 to 9
+  twoDigits: /^\d{1,2}/,
+  // 0 to 99
+  threeDigits: /^\d{1,3}/,
+  // 0 to 999
+  fourDigits: /^\d{1,4}/,
+  // 0 to 9999
+  anyDigitsSigned: /^-?\d+/,
+  singleDigitSigned: /^-?\d/,
+  // 0 to 9, -0 to -9
+  twoDigitsSigned: /^-?\d{1,2}/,
+  // 0 to 99, -0 to -99
+  threeDigitsSigned: /^-?\d{1,3}/,
+  // 0 to 999, -0 to -999
+  fourDigitsSigned: /^-?\d{1,4}/
+  // 0 to 9999, -0 to -9999
+};
+var timezonePatterns = {
+  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
+  basic: /^([+-])(\d{2})(\d{2})|Z/,
+  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
+  extended: /^([+-])(\d{2}):(\d{2})|Z/,
+  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/
+};
+
+// ../../node_modules/date-fns/parse/_lib/utils.mjs
+function mapValue(parseFnResult, mapFn) {
+  if (!parseFnResult) {
+    return parseFnResult;
+  }
+  return {
+    value: mapFn(parseFnResult.value),
+    rest: parseFnResult.rest
+  };
+}
+function parseNumericPattern(pattern, dateString) {
+  const matchResult = dateString.match(pattern);
+  if (!matchResult) {
+    return null;
+  }
+  return {
+    value: parseInt(matchResult[0], 10),
+    rest: dateString.slice(matchResult[0].length)
+  };
+}
+function parseTimezonePattern(pattern, dateString) {
+  const matchResult = dateString.match(pattern);
+  if (!matchResult) {
+    return null;
+  }
+  if (matchResult[0] === "Z") {
+    return {
+      value: 0,
+      rest: dateString.slice(1)
+    };
+  }
+  const sign = matchResult[1] === "+" ? 1 : -1;
+  const hours = matchResult[2] ? parseInt(matchResult[2], 10) : 0;
+  const minutes = matchResult[3] ? parseInt(matchResult[3], 10) : 0;
+  const seconds = matchResult[5] ? parseInt(matchResult[5], 10) : 0;
+  return {
+    value: sign * (hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * millisecondsInSecond),
+    rest: dateString.slice(matchResult[0].length)
+  };
+}
+function parseAnyDigitsSigned(dateString) {
+  return parseNumericPattern(numericPatterns.anyDigitsSigned, dateString);
+}
+function parseNDigits(n, dateString) {
+  switch (n) {
+    case 1:
+      return parseNumericPattern(numericPatterns.singleDigit, dateString);
+    case 2:
+      return parseNumericPattern(numericPatterns.twoDigits, dateString);
+    case 3:
+      return parseNumericPattern(numericPatterns.threeDigits, dateString);
+    case 4:
+      return parseNumericPattern(numericPatterns.fourDigits, dateString);
+    default:
+      return parseNumericPattern(new RegExp("^\\d{1," + n + "}"), dateString);
+  }
+}
+function parseNDigitsSigned(n, dateString) {
+  switch (n) {
+    case 1:
+      return parseNumericPattern(numericPatterns.singleDigitSigned, dateString);
+    case 2:
+      return parseNumericPattern(numericPatterns.twoDigitsSigned, dateString);
+    case 3:
+      return parseNumericPattern(numericPatterns.threeDigitsSigned, dateString);
+    case 4:
+      return parseNumericPattern(numericPatterns.fourDigitsSigned, dateString);
+    default:
+      return parseNumericPattern(new RegExp("^-?\\d{1," + n + "}"), dateString);
+  }
+}
+function dayPeriodEnumToHours(dayPeriod) {
+  switch (dayPeriod) {
+    case "morning":
+      return 4;
+    case "evening":
+      return 17;
+    case "pm":
+    case "noon":
+    case "afternoon":
+      return 12;
+    case "am":
+    case "midnight":
+    case "night":
+    default:
+      return 0;
+  }
+}
+function normalizeTwoDigitYear(twoDigitYear, currentYear) {
+  const isCommonEra = currentYear > 0;
+  const absCurrentYear = isCommonEra ? currentYear : 1 - currentYear;
+  let result;
+  if (absCurrentYear <= 50) {
+    result = twoDigitYear || 100;
+  } else {
+    const rangeEnd = absCurrentYear + 50;
+    const rangeEndCentury = Math.trunc(rangeEnd / 100) * 100;
+    const isPreviousCentury = twoDigitYear >= rangeEnd % 100;
+    result = twoDigitYear + rangeEndCentury - (isPreviousCentury ? 100 : 0);
+  }
+  return isCommonEra ? result : 1 - result;
+}
+function isLeapYearIndex(year) {
+  return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+}
+
+// ../../node_modules/date-fns/parse/_lib/parsers/YearParser.mjs
+var YearParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 130);
+    __publicField(this, "incompatibleTokens", ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    const valueCallback = (year) => ({
+      year,
+      isTwoDigitYear: token === "yy"
+    });
+    switch (token) {
+      case "y":
+        return mapValue(parseNDigits(4, dateString), valueCallback);
+      case "yo":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "year"
+          }),
+          valueCallback
+        );
+      default:
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+    }
+  }
+  validate(_date, value) {
+    return value.isTwoDigitYear || value.year > 0;
+  }
+  set(date, flags, value) {
+    const currentYear = date.getFullYear();
+    if (value.isTwoDigitYear) {
+      const normalizedTwoDigitYear = normalizeTwoDigitYear(
+        value.year,
+        currentYear
+      );
+      date.setFullYear(normalizedTwoDigitYear, 0, 1);
+      date.setHours(0, 0, 0, 0);
+      return date;
+    }
+    const year = !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+    date.setFullYear(year, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/LocalWeekYearParser.mjs
+var LocalWeekYearParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 130);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "Q",
+      "q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "i",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    const valueCallback = (year) => ({
+      year,
+      isTwoDigitYear: token === "YY"
+    });
+    switch (token) {
+      case "Y":
+        return mapValue(parseNDigits(4, dateString), valueCallback);
+      case "Yo":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "year"
+          }),
+          valueCallback
+        );
+      default:
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+    }
+  }
+  validate(_date, value) {
+    return value.isTwoDigitYear || value.year > 0;
+  }
+  set(date, flags, value, options) {
+    const currentYear = getWeekYear(date, options);
+    if (value.isTwoDigitYear) {
+      const normalizedTwoDigitYear = normalizeTwoDigitYear(
+        value.year,
+        currentYear
+      );
+      date.setFullYear(
+        normalizedTwoDigitYear,
+        0,
+        options.firstWeekContainsDate
+      );
+      date.setHours(0, 0, 0, 0);
+      return startOfWeek(date, options);
+    }
+    const year = !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+    date.setFullYear(year, 0, options.firstWeekContainsDate);
+    date.setHours(0, 0, 0, 0);
+    return startOfWeek(date, options);
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/ISOWeekYearParser.mjs
+var ISOWeekYearParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 130);
+    __publicField(this, "incompatibleTokens", [
+      "G",
+      "y",
+      "Y",
+      "u",
+      "Q",
+      "q",
+      "M",
+      "L",
+      "w",
+      "d",
+      "D",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token) {
+    if (token === "R") {
+      return parseNDigitsSigned(4, dateString);
+    }
+    return parseNDigitsSigned(token.length, dateString);
+  }
+  set(date, _flags, value) {
+    const firstWeekOfYear = constructFrom(date, 0);
+    firstWeekOfYear.setFullYear(value, 0, 4);
+    firstWeekOfYear.setHours(0, 0, 0, 0);
+    return startOfISOWeek(firstWeekOfYear);
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/ExtendedYearParser.mjs
+var ExtendedYearParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 130);
+    __publicField(this, "incompatibleTokens", ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"]);
+  }
+  parse(dateString, token) {
+    if (token === "u") {
+      return parseNDigitsSigned(4, dateString);
+    }
+    return parseNDigitsSigned(token.length, dateString);
+  }
+  set(date, _flags, value) {
+    date.setFullYear(value, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/QuarterParser.mjs
+var QuarterParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 120);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      // 1, 2, 3, 4
+      case "Q":
+      case "QQ":
+        return parseNDigits(token.length, dateString);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return match2.ordinalNumber(dateString, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return match2.quarter(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.quarter(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return match2.quarter(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return match2.quarter(dateString, {
+          width: "wide",
+          context: "formatting"
+        }) || match2.quarter(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.quarter(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 4;
+  }
+  set(date, _flags, value) {
+    date.setMonth((value - 1) * 3, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/StandAloneQuarterParser.mjs
+var StandAloneQuarterParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 120);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      // 1, 2, 3, 4
+      case "q":
+      case "qq":
+        return parseNDigits(token.length, dateString);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return match2.ordinalNumber(dateString, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return match2.quarter(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.quarter(dateString, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return match2.quarter(dateString, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "qqqq":
+      default:
+        return match2.quarter(dateString, {
+          width: "wide",
+          context: "standalone"
+        }) || match2.quarter(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.quarter(dateString, {
+          width: "narrow",
+          context: "standalone"
+        });
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 4;
+  }
+  set(date, _flags, value) {
+    date.setMonth((value - 1) * 3, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/MonthParser.mjs
+var MonthParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "L",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+    __publicField(this, "priority", 110);
+  }
+  parse(dateString, token, match2) {
+    const valueCallback = (value) => value - 1;
+    switch (token) {
+      // 1, 2, ..., 12
+      case "M":
+        return mapValue(
+          parseNumericPattern(numericPatterns.month, dateString),
+          valueCallback
+        );
+      // 01, 02, ..., 12
+      case "MM":
+        return mapValue(parseNDigits(2, dateString), valueCallback);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "month"
+          }),
+          valueCallback
+        );
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return match2.month(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.month(dateString, { width: "narrow", context: "formatting" });
+      // J, F, ..., D
+      case "MMMMM":
+        return match2.month(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return match2.month(dateString, { width: "wide", context: "formatting" }) || match2.month(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.month(dateString, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+  set(date, _flags, value) {
+    date.setMonth(value, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/StandAloneMonthParser.mjs
+var StandAloneMonthParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 110);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "M",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    const valueCallback = (value) => value - 1;
+    switch (token) {
+      // 1, 2, ..., 12
+      case "L":
+        return mapValue(
+          parseNumericPattern(numericPatterns.month, dateString),
+          valueCallback
+        );
+      // 01, 02, ..., 12
+      case "LL":
+        return mapValue(parseNDigits(2, dateString), valueCallback);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "month"
+          }),
+          valueCallback
+        );
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return match2.month(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.month(dateString, { width: "narrow", context: "standalone" });
+      // J, F, ..., D
+      case "LLLLL":
+        return match2.month(dateString, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // January, February, ..., December
+      case "LLLL":
+      default:
+        return match2.month(dateString, { width: "wide", context: "standalone" }) || match2.month(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.month(dateString, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+  set(date, _flags, value) {
+    date.setMonth(value, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/setWeek.mjs
+function setWeek(date, week, options) {
+  const _date = toDate(date);
+  const diff = getWeek(_date, options) - week;
+  _date.setDate(_date.getDate() - diff * 7);
+  return _date;
+}
+
+// ../../node_modules/date-fns/parse/_lib/parsers/LocalWeekParser.mjs
+var LocalWeekParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 100);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "i",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "w":
+        return parseNumericPattern(numericPatterns.week, dateString);
+      case "wo":
+        return match2.ordinalNumber(dateString, { unit: "week" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 53;
+  }
+  set(date, _flags, value, options) {
+    return startOfWeek(setWeek(date, value, options), options);
+  }
+};
+
+// ../../node_modules/date-fns/setISOWeek.mjs
+function setISOWeek(date, week) {
+  const _date = toDate(date);
+  const diff = getISOWeek(_date) - week;
+  _date.setDate(_date.getDate() - diff * 7);
+  return _date;
+}
+
+// ../../node_modules/date-fns/parse/_lib/parsers/ISOWeekParser.mjs
+var ISOWeekParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 100);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "Y",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "d",
+      "D",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "I":
+        return parseNumericPattern(numericPatterns.week, dateString);
+      case "Io":
+        return match2.ordinalNumber(dateString, { unit: "week" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 53;
+  }
+  set(date, _flags, value) {
+    return startOfISOWeek(setISOWeek(date, value));
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/DateParser.mjs
+var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var DAYS_IN_MONTH_LEAP_YEAR = [
+  31,
+  29,
+  31,
+  30,
+  31,
+  30,
+  31,
+  31,
+  30,
+  31,
+  30,
+  31
+];
+var DateParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "subPriority", 1);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "d":
+        return parseNumericPattern(numericPatterns.date, dateString);
+      case "do":
+        return match2.ordinalNumber(dateString, { unit: "date" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(date, value) {
+    const year = date.getFullYear();
+    const isLeapYear = isLeapYearIndex(year);
+    const month = date.getMonth();
+    if (isLeapYear) {
+      return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
+    } else {
+      return value >= 1 && value <= DAYS_IN_MONTH[month];
+    }
+  }
+  set(date, _flags, value) {
+    date.setDate(value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/DayOfYearParser.mjs
+var DayOfYearParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "subpriority", 1);
+    __publicField(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "E",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "D":
+      case "DD":
+        return parseNumericPattern(numericPatterns.dayOfYear, dateString);
+      case "Do":
+        return match2.ordinalNumber(dateString, { unit: "date" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(date, value) {
+    const year = date.getFullYear();
+    const isLeapYear = isLeapYearIndex(year);
+    if (isLeapYear) {
+      return value >= 1 && value <= 366;
+    } else {
+      return value >= 1 && value <= 365;
+    }
+  }
+  set(date, _flags, value) {
+    date.setMonth(0, value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/setDay.mjs
+function setDay(date, day, options) {
+  const defaultOptions2 = getDefaultOptions();
+  const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
+  const _date = toDate(date);
+  const currentDay = _date.getDay();
+  const remainder = day % 7;
+  const dayIndex = (remainder + 7) % 7;
+  const delta = 7 - weekStartsOn;
+  const diff = day < 0 || day > 6 ? day - (currentDay + delta) % 7 : (dayIndex + delta) % 7 - (currentDay + delta) % 7;
+  return addDays(_date, diff);
+}
+
+// ../../node_modules/date-fns/parse/_lib/parsers/DayParser.mjs
+var DayParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "incompatibleTokens", ["D", "i", "e", "c", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return match2.day(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+      // T
+      case "EEEEE":
+        return match2.day(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "EEEEEE":
+        return match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+      // Tuesday
+      case "EEEE":
+      default:
+        return match2.day(dateString, { width: "wide", context: "formatting" }) || match2.day(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+  set(date, _flags, value, options) {
+    date = setDay(date, value, options);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/LocalDayParser.mjs
+var LocalDayParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "E",
+      "i",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2, options) {
+    const valueCallback = (value) => {
+      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+      return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
+    };
+    switch (token) {
+      // 3
+      case "e":
+      case "ee":
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+      // 3rd
+      case "eo":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "day"
+          }),
+          valueCallback
+        );
+      // Tue
+      case "eee":
+        return match2.day(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+      // T
+      case "eeeee":
+        return match2.day(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "eeeeee":
+        return match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+      // Tuesday
+      case "eeee":
+      default:
+        return match2.day(dateString, { width: "wide", context: "formatting" }) || match2.day(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+  set(date, _flags, value, options) {
+    date = setDay(date, value, options);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/StandAloneLocalDayParser.mjs
+var StandAloneLocalDayParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "E",
+      "i",
+      "e",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2, options) {
+    const valueCallback = (value) => {
+      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+      return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
+    };
+    switch (token) {
+      // 3
+      case "c":
+      case "cc":
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+      // 3rd
+      case "co":
+        return mapValue(
+          match2.ordinalNumber(dateString, {
+            unit: "day"
+          }),
+          valueCallback
+        );
+      // Tue
+      case "ccc":
+        return match2.day(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
+      // T
+      case "ccccc":
+        return match2.day(dateString, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // Tu
+      case "cccccc":
+        return match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
+      // Tuesday
+      case "cccc":
+      default:
+        return match2.day(dateString, { width: "wide", context: "standalone" }) || match2.day(dateString, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+  set(date, _flags, value, options) {
+    date = setDay(date, value, options);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/setISODay.mjs
+function setISODay(date, day) {
+  const _date = toDate(date);
+  const currentDay = getISODay(_date);
+  const diff = day - currentDay;
+  return addDays(_date, diff);
+}
+
+// ../../node_modules/date-fns/parse/_lib/parsers/ISODayParser.mjs
+var ISODayParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 90);
+    __publicField(this, "incompatibleTokens", [
+      "y",
+      "Y",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "d",
+      "D",
+      "E",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(dateString, token, match2) {
+    const valueCallback = (value) => {
+      if (value === 0) {
+        return 7;
+      }
+      return value;
+    };
+    switch (token) {
+      // 2
+      case "i":
+      case "ii":
+        return parseNDigits(token.length, dateString);
+      // 2nd
+      case "io":
+        return match2.ordinalNumber(dateString, { unit: "day" });
+      // Tue
+      case "iii":
+        return mapValue(
+          match2.day(dateString, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "short",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          valueCallback
+        );
+      // T
+      case "iiiii":
+        return mapValue(
+          match2.day(dateString, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          valueCallback
+        );
+      // Tu
+      case "iiiiii":
+        return mapValue(
+          match2.day(dateString, {
+            width: "short",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          valueCallback
+        );
+      // Tuesday
+      case "iiii":
+      default:
+        return mapValue(
+          match2.day(dateString, {
+            width: "wide",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "short",
+            context: "formatting"
+          }) || match2.day(dateString, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          valueCallback
+        );
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 7;
+  }
+  set(date, _flags, value) {
+    date = setISODay(date, value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/AMPMParser.mjs
+var AMPMParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 80);
+    __publicField(this, "incompatibleTokens", ["b", "B", "H", "k", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "a":
+      case "aa":
+      case "aaa":
+        return match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaaa":
+        return match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaa":
+      default:
+        return match2.dayPeriod(dateString, {
+          width: "wide",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(date, _flags, value) {
+    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/AMPMMidnightParser.mjs
+var AMPMMidnightParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 80);
+    __publicField(this, "incompatibleTokens", ["a", "B", "H", "k", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "b":
+      case "bb":
+      case "bbb":
+        return match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbbb":
+        return match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbb":
+      default:
+        return match2.dayPeriod(dateString, {
+          width: "wide",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(date, _flags, value) {
+    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/DayPeriodParser.mjs
+var DayPeriodParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 80);
+    __publicField(this, "incompatibleTokens", ["a", "b", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBB":
+      default:
+        return match2.dayPeriod(dateString, {
+          width: "wide",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || match2.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(date, _flags, value) {
+    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/Hour1to12Parser.mjs
+var Hour1to12Parser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 70);
+    __publicField(this, "incompatibleTokens", ["H", "K", "k", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "h":
+        return parseNumericPattern(numericPatterns.hour12h, dateString);
+      case "ho":
+        return match2.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 12;
+  }
+  set(date, _flags, value) {
+    const isPM = date.getHours() >= 12;
+    if (isPM && value < 12) {
+      date.setHours(value + 12, 0, 0, 0);
+    } else if (!isPM && value === 12) {
+      date.setHours(0, 0, 0, 0);
+    } else {
+      date.setHours(value, 0, 0, 0);
+    }
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/Hour0to23Parser.mjs
+var Hour0to23Parser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 70);
+    __publicField(this, "incompatibleTokens", ["a", "b", "h", "K", "k", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "H":
+        return parseNumericPattern(numericPatterns.hour23h, dateString);
+      case "Ho":
+        return match2.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 23;
+  }
+  set(date, _flags, value) {
+    date.setHours(value, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/Hour0To11Parser.mjs
+var Hour0To11Parser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 70);
+    __publicField(this, "incompatibleTokens", ["h", "H", "k", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "K":
+        return parseNumericPattern(numericPatterns.hour11h, dateString);
+      case "Ko":
+        return match2.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+  set(date, _flags, value) {
+    const isPM = date.getHours() >= 12;
+    if (isPM && value < 12) {
+      date.setHours(value + 12, 0, 0, 0);
+    } else {
+      date.setHours(value, 0, 0, 0);
+    }
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/Hour1To24Parser.mjs
+var Hour1To24Parser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 70);
+    __publicField(this, "incompatibleTokens", ["a", "b", "h", "H", "K", "t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "k":
+        return parseNumericPattern(numericPatterns.hour24h, dateString);
+      case "ko":
+        return match2.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 1 && value <= 24;
+  }
+  set(date, _flags, value) {
+    const hours = value <= 24 ? value % 24 : value;
+    date.setHours(hours, 0, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/MinuteParser.mjs
+var MinuteParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 60);
+    __publicField(this, "incompatibleTokens", ["t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "m":
+        return parseNumericPattern(numericPatterns.minute, dateString);
+      case "mo":
+        return match2.ordinalNumber(dateString, { unit: "minute" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 59;
+  }
+  set(date, _flags, value) {
+    date.setMinutes(value, 0, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/SecondParser.mjs
+var SecondParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 50);
+    __publicField(this, "incompatibleTokens", ["t", "T"]);
+  }
+  parse(dateString, token, match2) {
+    switch (token) {
+      case "s":
+        return parseNumericPattern(numericPatterns.second, dateString);
+      case "so":
+        return match2.ordinalNumber(dateString, { unit: "second" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+  validate(_date, value) {
+    return value >= 0 && value <= 59;
+  }
+  set(date, _flags, value) {
+    date.setSeconds(value, 0);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/FractionOfSecondParser.mjs
+var FractionOfSecondParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 30);
+    __publicField(this, "incompatibleTokens", ["t", "T"]);
+  }
+  parse(dateString, token) {
+    const valueCallback = (value) => Math.trunc(value * Math.pow(10, -token.length + 3));
+    return mapValue(parseNDigits(token.length, dateString), valueCallback);
+  }
+  set(date, _flags, value) {
+    date.setMilliseconds(value);
+    return date;
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/ISOTimezoneWithZParser.mjs
+var ISOTimezoneWithZParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 10);
+    __publicField(this, "incompatibleTokens", ["t", "T", "x"]);
+  }
+  parse(dateString, token) {
+    switch (token) {
+      case "X":
+        return parseTimezonePattern(
+          timezonePatterns.basicOptionalMinutes,
+          dateString
+        );
+      case "XX":
+        return parseTimezonePattern(timezonePatterns.basic, dateString);
+      case "XXXX":
+        return parseTimezonePattern(
+          timezonePatterns.basicOptionalSeconds,
+          dateString
+        );
+      case "XXXXX":
+        return parseTimezonePattern(
+          timezonePatterns.extendedOptionalSeconds,
+          dateString
+        );
+      case "XXX":
+      default:
+        return parseTimezonePattern(timezonePatterns.extended, dateString);
+    }
+  }
+  set(date, flags, value) {
+    if (flags.timestampIsSet) return date;
+    return constructFrom(
+      date,
+      date.getTime() - getTimezoneOffsetInMilliseconds(date) - value
+    );
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/ISOTimezoneParser.mjs
+var ISOTimezoneParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 10);
+    __publicField(this, "incompatibleTokens", ["t", "T", "X"]);
+  }
+  parse(dateString, token) {
+    switch (token) {
+      case "x":
+        return parseTimezonePattern(
+          timezonePatterns.basicOptionalMinutes,
+          dateString
+        );
+      case "xx":
+        return parseTimezonePattern(timezonePatterns.basic, dateString);
+      case "xxxx":
+        return parseTimezonePattern(
+          timezonePatterns.basicOptionalSeconds,
+          dateString
+        );
+      case "xxxxx":
+        return parseTimezonePattern(
+          timezonePatterns.extendedOptionalSeconds,
+          dateString
+        );
+      case "xxx":
+      default:
+        return parseTimezonePattern(timezonePatterns.extended, dateString);
+    }
+  }
+  set(date, flags, value) {
+    if (flags.timestampIsSet) return date;
+    return constructFrom(
+      date,
+      date.getTime() - getTimezoneOffsetInMilliseconds(date) - value
+    );
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/TimestampSecondsParser.mjs
+var TimestampSecondsParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 40);
+    __publicField(this, "incompatibleTokens", "*");
+  }
+  parse(dateString) {
+    return parseAnyDigitsSigned(dateString);
+  }
+  set(date, _flags, value) {
+    return [constructFrom(date, value * 1e3), { timestampIsSet: true }];
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers/TimestampMillisecondsParser.mjs
+var TimestampMillisecondsParser = class extends Parser {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "priority", 20);
+    __publicField(this, "incompatibleTokens", "*");
+  }
+  parse(dateString) {
+    return parseAnyDigitsSigned(dateString);
+  }
+  set(date, _flags, value) {
+    return [constructFrom(date, value), { timestampIsSet: true }];
+  }
+};
+
+// ../../node_modules/date-fns/parse/_lib/parsers.mjs
+var parsers = {
+  G: new EraParser(),
+  y: new YearParser(),
+  Y: new LocalWeekYearParser(),
+  R: new ISOWeekYearParser(),
+  u: new ExtendedYearParser(),
+  Q: new QuarterParser(),
+  q: new StandAloneQuarterParser(),
+  M: new MonthParser(),
+  L: new StandAloneMonthParser(),
+  w: new LocalWeekParser(),
+  I: new ISOWeekParser(),
+  d: new DateParser(),
+  D: new DayOfYearParser(),
+  E: new DayParser(),
+  e: new LocalDayParser(),
+  c: new StandAloneLocalDayParser(),
+  i: new ISODayParser(),
+  a: new AMPMParser(),
+  b: new AMPMMidnightParser(),
+  B: new DayPeriodParser(),
+  h: new Hour1to12Parser(),
+  H: new Hour0to23Parser(),
+  K: new Hour0To11Parser(),
+  k: new Hour1To24Parser(),
+  m: new MinuteParser(),
+  s: new SecondParser(),
+  S: new FractionOfSecondParser(),
+  X: new ISOTimezoneWithZParser(),
+  x: new ISOTimezoneParser(),
+  t: new TimestampSecondsParser(),
+  T: new TimestampMillisecondsParser()
+};
+
+// ../../node_modules/date-fns/parse.mjs
+var formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
+var longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
+var escapedStringRegExp = /^'([^]*?)'?$/;
+var doubleQuoteRegExp = /''/g;
+var notWhitespaceRegExp = /\S/;
+var unescapedLatinCharacterRegExp = /[a-zA-Z]/;
+function parse(dateStr, formatStr, referenceDate, options) {
+  const defaultOptions2 = getDefaultOptions2();
+  const locale = defaultOptions2.locale ?? enUS;
+  const firstWeekContainsDate = defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
+  const weekStartsOn = defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
+  const subFnOptions = {
+    firstWeekContainsDate,
+    weekStartsOn,
+    locale
+  };
+  const setters = [new DateToSystemTimezoneSetter()];
+  const tokens = formatStr.match(longFormattingTokensRegExp).map((substring) => {
+    const firstCharacter = substring[0];
+    if (firstCharacter in longFormatters) {
+      const longFormatter = longFormatters[firstCharacter];
+      return longFormatter(substring, locale.formatLong);
+    }
+    return substring;
+  }).join("").match(formattingTokensRegExp);
+  const usedTokens = [];
+  for (let token of tokens) {
+    if (isProtectedWeekYearToken(token)) {
+      warnOrThrowProtectedError(token, formatStr, dateStr);
+    }
+    if (isProtectedDayOfYearToken(token)) {
+      warnOrThrowProtectedError(token, formatStr, dateStr);
+    }
+    const firstCharacter = token[0];
+    const parser = parsers[firstCharacter];
+    if (parser) {
+      const { incompatibleTokens } = parser;
+      if (Array.isArray(incompatibleTokens)) {
+        const incompatibleToken = usedTokens.find(
+          (usedToken) => incompatibleTokens.includes(usedToken.token) || usedToken.token === firstCharacter
+        );
+        if (incompatibleToken) {
+          throw new RangeError(
+            `The format string mustn't contain \`${incompatibleToken.fullToken}\` and \`${token}\` at the same time`
+          );
+        }
+      } else if (parser.incompatibleTokens === "*" && usedTokens.length > 0) {
+        throw new RangeError(
+          `The format string mustn't contain \`${token}\` and any other token at the same time`
+        );
+      }
+      usedTokens.push({ token: firstCharacter, fullToken: token });
+      const parseResult = parser.run(
+        dateStr,
+        token,
+        locale.match,
+        subFnOptions
+      );
+      if (!parseResult) {
+        return constructFrom(referenceDate, NaN);
+      }
+      setters.push(parseResult.setter);
+      dateStr = parseResult.rest;
+    } else {
+      if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
+        throw new RangeError(
+          "Format string contains an unescaped latin alphabet character `" + firstCharacter + "`"
+        );
+      }
+      if (token === "''") {
+        token = "'";
+      } else if (firstCharacter === "'") {
+        token = cleanEscapedString(token);
+      }
+      if (dateStr.indexOf(token) === 0) {
+        dateStr = dateStr.slice(token.length);
+      } else {
+        return constructFrom(referenceDate, NaN);
+      }
+    }
+  }
+  if (dateStr.length > 0 && notWhitespaceRegExp.test(dateStr)) {
+    return constructFrom(referenceDate, NaN);
+  }
+  const uniquePrioritySetters = setters.map((setter) => setter.priority).sort((a, b) => b - a).filter((priority, index, array) => array.indexOf(priority) === index).map(
+    (priority) => setters.filter((setter) => setter.priority === priority).sort((a, b) => b.subPriority - a.subPriority)
+  ).map((setterArray) => setterArray[0]);
+  let date = toDate(referenceDate);
+  if (isNaN(date.getTime())) {
+    return constructFrom(referenceDate, NaN);
+  }
+  const flags = {};
+  for (const setter of uniquePrioritySetters) {
+    if (!setter.validate(date, subFnOptions)) {
+      return constructFrom(referenceDate, NaN);
+    }
+    const result = setter.set(date, flags, subFnOptions);
+    if (Array.isArray(result)) {
+      date = result[0];
+      Object.assign(flags, result[1]);
+    } else {
+      date = result;
+    }
+  }
+  return constructFrom(referenceDate, date);
+}
+function cleanEscapedString(input) {
+  return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, "'");
+}
+
+// src/types/schema-form-builder.ts
+function hydrateField(raw, currentPage) {
+  return {
+    ...raw,
+    rules_count: Object.keys(raw.show ?? {}).length,
+    show_on_this_page: raw.page === currentPage,
+    visible: false,
+    is_visible: false,
+    aws_lookup: raw.lookup?.aws_table != null
+  };
+}
+
+// src/utils/formSchemaApi.ts
+function isApiError(result) {
+  return result.error === true;
+}
+async function getFormSchema(formId, appConfig) {
+  try {
+    const response = await fetch(`${appConfig.apiBaseUrl}/form/schema`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        clienttoken: appConfig.blApiToken
+      },
+      body: JSON.stringify({
+        company: appConfig.company_id,
+        client: appConfig.customer_name,
+        form_name: formId
+      })
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    return await response.json();
+  } catch (err) {
+    return { error: true, message: err.message };
+  }
+}
+async function getAddressLookup(postcode, appConfig) {
+  try {
+    const response = await fetch(
+      `${appConfig.apiBaseUrl}/ordnance_survey/postcode/${encodeURIComponent(postcode)}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          clienttoken: appConfig.blApiToken
+        }
+      }
+    );
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const data = await response.json();
+    return Array.isArray(data) ? data : data.results ?? [];
+  } catch (err) {
+    return { error: true, message: err.message };
+  }
+}
+async function awsLookup(appConfig, table, field, reference, referenceExtra, fieldExtra) {
+  try {
+    const body = {
+      client: appConfig.customer_name,
+      reference,
+      table,
+      field
+    };
+    if (referenceExtra && fieldExtra) {
+      body["referenceExtra"] = fieldExtra;
+      body["field_extra"] = referenceExtra;
+    }
+    const response = await fetch(`${appConfig.apiBaseUrl}/eligibility_reference_lookup`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        clienttoken: appConfig.blApiToken
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    return await response.json();
+  } catch (err) {
+    return { error: true, message: err.message };
+  }
+}
+async function getExtraItemProperties(bookingQuestionCode, companyId, serviceId, appConfig) {
+  try {
+    const response = await fetch(
+      `${appConfig.apiBaseUrl}/company/${companyId}/extra-item/${bookingQuestionCode}/service/${serviceId}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          clienttoken: appConfig.blApiToken
+        }
+      }
+    );
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    return await response.json();
+  } catch (err) {
+    return { error: true, message: err.message };
+  }
+}
+async function searchVenue(companyId, query, appConfig) {
+  try {
+    const response = await fetch(
+      `${appConfig.apiBaseUrl}/company/${companyId}/venue-lookup?search=${encodeURIComponent(query.toLowerCase())}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          "x-company-id": companyId,
+          clienttoken: appConfig.blApiToken
+        }
+      }
+    );
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const data = await response.json();
+    return Array.isArray(data) ? data : [];
+  } catch (err) {
+    return { error: true, message: err.message };
+  }
+}
+function requiredValidator(value) {
+  if (value === "" || value == null) return { key: "required" };
+  return null;
+}
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function emailValidator(value) {
+  if (!value) return null;
+  return EMAIL_REGEX.test(value) ? null : { key: "email" };
+}
+var UK_MOBILE_REGEX = /^(?:0|\+44)7\d{9}$/;
+function mobileValidator(value) {
+  if (!value) return null;
+  return UK_MOBILE_REGEX.test(value) ? null : { key: "pattern", message: "Enter a valid UK mobile number." };
+}
+var UK_PHONE_REGEX = /^(?:0|\+44)\s?\d{10}$/;
+function phoneValidator(value) {
+  if (!value) return null;
+  return UK_PHONE_REGEX.test(value) ? null : { key: "pattern", message: "Enter a valid UK phone number." };
+}
+function minLengthValidator(min) {
+  return (value) => {
+    if (!value) return null;
+    return value.length >= min ? null : { key: "minlength", requiredLength: min };
+  };
+}
+function maxLengthValidator(max) {
+  return (value) => {
+    if (!value) return null;
+    return value.length <= max ? null : { key: "maxlength", requiredLength: max };
+  };
+}
+function minDateValidator(minDateStr) {
+  return (value) => {
+    if (!value) return null;
+    const controlDate = startOfDay(new Date(value));
+    const minDate = startOfDay(parse(minDateStr, "dd-MM-yyyy", /* @__PURE__ */ new Date()));
+    if (!isValid(controlDate)) return { key: "invalidDate", message: "Invalid date format" };
+    return isBefore(controlDate, minDate) ? { key: "minDate", message: "Date cannot be in the past" } : null;
+  };
+}
+function maxDateValidator(noOfDays) {
+  return (value) => {
+    if (!value) return null;
+    const maxDate = startOfDay(addDays(/* @__PURE__ */ new Date(), noOfDays));
+    const controlDate = startOfDay(new Date(value));
+    return isAfter(controlDate, maxDate) ? { key: "maxDate", message: "Date cannot be in the future" } : null;
+  };
+}
+function buildValidators(field) {
+  const validators = [];
+  if (field.required) validators.push(requiredValidator);
+  if (!Array.isArray(field.validation)) return validators;
+  for (const rule of field.validation) {
+    if (typeof rule === "string") {
+      switch (rule) {
+        case "email":
+          validators.push(emailValidator);
+          break;
+        case "mobile":
+          validators.push(mobileValidator);
+          break;
+        case "phone":
+        case "contact":
+          validators.push(phoneValidator);
+          break;
+        case "length":
+          validators.push(maxLengthValidator(255));
+          break;
+      }
+    } else if (typeof rule === "object" && rule !== null) {
+      if ("minLength" in rule) validators.push(minLengthValidator(rule.minLength));
+      if ("maxLength" in rule) validators.push(maxLengthValidator(rule.maxLength));
+      if ("minDate" in rule) validators.push(minDateValidator(rule.minDate));
+      if ("maxDate" in rule) validators.push(maxDateValidator(rule.maxDate));
+    }
+  }
+  return validators;
+}
+function getErrorMessage(error) {
+  switch (error.key) {
+    case "required":
+      return "This field is required.";
+    case "minlength":
+      return `Minimum length is ${error.requiredLength ?? 0} characters.`;
+    case "maxlength":
+      return `Maximum length is ${error.requiredLength ?? 0} characters.`;
+    case "email":
+      return "Enter a valid email address.";
+    case "pattern":
+      return error.message ?? "Invalid format.";
+    case "minDate":
+      return error.message ?? "Date cannot be in the past.";
+    case "maxDate":
+      return error.message ?? "Date cannot be in the future.";
+    case "invalidDate":
+      return error.message ?? "Enter a valid date.";
+    default:
+      return error.message ?? "Invalid input.";
+  }
+}
+function getInputType(field) {
+  if (field.type === "number" && Array.isArray(field.validation) && field.validation.some((v) => typeof v === "string" && ["phone", "mobile", "contact"].includes(v))) {
+    return "tel";
+  }
+  return field.type;
+}
+var SESSION_STORAGE_KEY = "form_builder_answers";
+function getAnswerStore() {
+  try {
+    const raw = sessionStorage.getItem(SESSION_STORAGE_KEY);
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+function getStoredAnswer(formId, fieldName) {
+  const store = getAnswerStore();
+  const value = store?.[formId]?.[fieldName];
+  return value != null ? String(value) : null;
+}
+function persistAnswer(formId, fieldName, value) {
+  if (!formId) return;
+  const store = getAnswerStore();
+  if (!store[formId]) store[formId] = {};
+  store[formId][fieldName] = value;
+  try {
+    sessionStorage.setItem(SESSION_STORAGE_KEY, JSON.stringify(store));
+  } catch (err) {
+    console.warn("[FormBuilder] Failed to persist answer to sessionStorage:", err);
+  }
+}
+function SchemaFormBuilder(props) {
+  const {
+    formId,
+    appConfig,
+    currentPage,
+    companyId,
+    formData,
+    showSubmit: showSubmitProp,
+    formUpdateId,
+    initialSchema,
+    onFormSubmit,
+    onFormStatus,
+    onSchema,
+    onCompanySet,
+    onServiceSet,
+    onResourceSet,
+    onStaffSet,
+    onAddDuration,
+    onFormReady,
+    onUpdateDatastore,
+    onAddressSet,
+    onAwsLookupSet,
+    onExtraItemSet,
+    onExtraItemChanged,
+    onVenueSet,
+    onProcessing
+  } = props;
+  const [formValues, setFormValues] = react.useState({});
+  const [formFields, setFormFields] = react.useState([]);
+  const [schema, setSchema] = react.useState(null);
+  const [showSubmit, setShowSubmit] = react.useState(showSubmitProp ?? false);
+  const [loading, setLoading] = react.useState(true);
+  const [suggestions, setSuggestions] = react.useState([]);
+  const [, _setSearching] = react.useState(false);
+  const [searchText, setSearchText] = react.useState("");
+  const [touchedFields, setTouchedFields] = react.useState(/* @__PURE__ */ new Set());
+  const [dirtyFields, setDirtyFields] = react.useState(/* @__PURE__ */ new Set());
+  const formServicesRef = react.useRef({});
+  const extraItemsRef = react.useRef([]);
+  const pendingExtraItemFetchesRef = react.useRef(/* @__PURE__ */ new Set());
+  const venueSearchTimerRef = react.useRef(null);
+  const activeFormIdRef = react.useRef("");
+  const initialisedRef = react.useRef(false);
+  const validatorMapRef = react.useRef(/* @__PURE__ */ new Map());
+  react.useEffect(() => {
+    if (initialisedRef.current && formUpdateId === activeFormIdRef.current && !initialSchema) return;
+    initialisedRef.current = true;
+    activeFormIdRef.current = formUpdateId ?? formId;
+    initialiseForm(formUpdateId ?? formId);
+  }, [formId, formUpdateId, initialSchema]);
+  react.useEffect(() => {
+    if (formFields.length > 0) {
+      refreshVisibility();
+    }
+    if (formFields.length > 0) {
+      const errors = [];
+      for (const field of formFields) {
+        if (field.page !== currentPage) continue;
+        if (!field.visible && !field.is_visible) continue;
+        const value = formValues[field.field] ?? "";
+        const fieldErrors = validateField(field, value);
+        if (fieldErrors) {
+          errors.push({ fieldName: field.field, errors: fieldErrors });
+        }
+      }
+      const serviceSetField = formFields.find(
+        (f) => f.page === currentPage && f.service_set && (f.visible || f.is_visible)
+      );
+      onFormStatus?.({
+        status: errors.length === 0,
+        errors,
+        formData: formValues,
+        extraItems: extraItemsRef.current,
+        setService: serviceSetField?.service_set
+      });
+    }
+  }, [formValues]);
+  react.useEffect(() => {
+    if (!formFields.length) return;
+    const visibleFieldsWithExtraItems = formFields.filter(
+      (f) => f.page === currentPage && (f.visible || f.is_visible) && (f["extra-item"] || f.resource_ids)
+    );
+    for (const field of visibleFieldsWithExtraItems) {
+      void setExtraItems(field);
+    }
+  }, [formFields, formValues]);
+  react.useEffect(() => {
+    return () => {
+      if (venueSearchTimerRef.current) {
+        clearTimeout(venueSearchTimerRef.current);
+      }
+    };
+  }, []);
+  const setFieldValue = react.useCallback(
+    (fieldName, value, _options) => {
+      setFormValues((prev) => ({ ...prev, [fieldName]: value }));
+      persistAnswer(formId, fieldName, value);
+    },
+    [formId]
+  );
+  async function initialiseForm(resolvedFormId) {
+    var _a;
+    setLoading(true);
+    setFormFields([]);
+    setFormValues({});
+    setSchema(null);
+    setShowSubmit(false);
+    extraItemsRef.current = [];
+    pendingExtraItemFetchesRef.current = /* @__PURE__ */ new Set();
+    (_a = formServicesRef.current)[resolvedFormId] ?? (_a[resolvedFormId] = {});
+    let result;
+    if (initialSchema) {
+      result = initialSchema;
+    } else {
+      const apiResult = await getFormSchema(resolvedFormId, appConfig);
+      if (isApiError(apiResult)) {
+        console.error("[FormBuilder] Failed to fetch form schema:", apiResult.message);
+        setLoading(false);
+        return;
+      }
+      result = apiResult;
+    }
+    const rawFields = result.schema.fields.filter((f) => f.field !== "haf_id");
+    const hydrated = rawFields.map((f) => hydrateField(f, currentPage));
+    const initialValues = {};
+    for (const field of hydrated) {
+      if (!field.show_on_this_page) continue;
+      initialValues[field.field] = "";
+      if (field.address_lookup) {
+        initialValues[`${field.field}_postcode`] = "";
+      }
+    }
+    if (formData) {
+      for (const [key, value] of Object.entries(formData)) {
+        if (key in initialValues) {
+          initialValues[key] = String(value ?? "");
+        }
+      }
+    }
+    const copyDataTargets = /* @__PURE__ */ new Set();
+    for (const field of hydrated) {
+      if (field.copy_data?.to) {
+        for (const target of field.copy_data.to) {
+          copyDataTargets.add(target);
+        }
+      }
+    }
+    if (copyDataTargets.size > 0) {
+      const storedAnswers = getAnswerStore()[resolvedFormId] ?? {};
+      for (const target of copyDataTargets) {
+        if (target in initialValues && !initialValues[target] && storedAnswers[target] != null) {
+          initialValues[target] = String(storedAnswers[target]);
+        }
+      }
+    }
+    validatorMapRef.current = /* @__PURE__ */ new Map();
+    for (const field of hydrated) {
+      validatorMapRef.current.set(field.field, buildValidators(field));
+    }
+    setSchema(result);
+    setFormFields(hydrated);
+    setFormValues(initialValues);
+    setTouchedFields(/* @__PURE__ */ new Set());
+    setDirtyFields(/* @__PURE__ */ new Set());
+    onFormReady?.({
+      form_id: resolvedFormId,
+      extra_items: extraItemsRef.current
+    });
+    setLoading(false);
+  }
+  function validateField(field, value) {
+    if (!field.visible && !field.is_visible) return null;
+    const validators = validatorMapRef.current.get(field.field) ?? buildValidators(field);
+    for (const validator of validators) {
+      const error = validator(value);
+      if (error) return error;
+    }
+    return null;
+  }
+  function markAsTouched(fieldName) {
+    setTouchedFields((prev) => new Set(prev).add(fieldName));
+  }
+  function markAsDirty(fieldName) {
+    setDirtyFields((prev) => new Set(prev).add(fieldName));
+  }
+  function markAllAsTouched() {
+    const allFieldNames = formFields.filter((f) => f.show_on_this_page).map((f) => f.field);
+    setTouchedFields(new Set(allFieldNames));
+  }
+  function shouldShowError(fieldName) {
+    return touchedFields.has(fieldName) || dirtyFields.has(fieldName);
+  }
+  function refreshVisibility() {
+    if (!formFields.length) return;
+    let continueVisible = false;
+    const schemaType = schema?.schema?.type ?? "extended";
+    const updatedFields = formFields.map((field) => {
+      if (field.page !== currentPage) return field;
+      const wasVisible = field.visible;
+      const hasShowRules = field.show != null && Object.keys(field.show).length > 0;
+      let isVisible;
+      if (schemaType === "extended") {
+        isVisible = hasShowRules ? evaluateExtendedConditional(field) : evaluateAlwaysVisible(field);
+      } else {
+        isVisible = evaluateLegacyConditional(field);
+      }
+      if (!isVisible && wasVisible) {
+        setFormValues((prev) => {
+          if (prev[field.field] === "" || prev[field.field] == null) return prev;
+          const next = { ...prev, [field.field]: "" };
+          return next;
+        });
+      }
+      if (isVisible && field.continue === true) {
+        continueVisible = true;
+      }
+      return { ...field, visible: isVisible, is_visible: isVisible };
+    });
+    setFormFields(updatedFields);
+    setShowSubmit(continueVisible);
+  }
+  function evaluateAlwaysVisible(field) {
+    resolveDynamicTitle(field);
+    fireVisibleSideEffects(field, true);
+    if (isAppointmentTypeFiltered(field)) return false;
+    return true;
+  }
+  function evaluateExtendedConditional(field) {
+    resolveDynamicTitle(field);
+    const rules = field.show;
+    const customResults = [];
+    const simpleResults = [];
+    if ("custom_all_lookups_successful" in rules) {
+      customResults.push(checkAllLookupsSuccessful(field.field));
+    }
+    if (rules.custom) {
+      customResults.push(evaluateCustomCondition(rules.custom));
+    }
+    if (rules.custom_multiple_condition) {
+      customResults.push(evaluateAndGroup(rules.custom_multiple_condition));
+    }
+    if (rules.custom_multiple_conditions) {
+      customResults.push(evaluateOrOfAndGroups(rules.custom_multiple_conditions));
+    }
+    if (rules.custom_or_condition) {
+      customResults.push(evaluateOrGroup(rules.custom_or_condition));
+    }
+    const RESERVED_RULE_KEYS = /* @__PURE__ */ new Set([
+      "custom",
+      "custom_multiple_condition",
+      "custom_multiple_conditions",
+      "custom_or_condition",
+      "custom_all_lookups_successful"
+    ]);
+    for (const [targetField, expectedValue] of Object.entries(rules)) {
+      if (RESERVED_RULE_KEYS.has(targetField)) continue;
+      simpleResults.push(evaluateSimpleRule(targetField, expectedValue));
+    }
+    let isVisible;
+    const simplePass = simpleResults.length === 0 || simpleResults.some((r) => r);
+    const customPass = customResults.length === 0 || customResults.every((r) => r);
+    if (simpleResults.length > 0 && customResults.length > 0) {
+      isVisible = simplePass && customPass;
+    } else if (customResults.length > 0) {
+      isVisible = customPass;
+    } else {
+      isVisible = simplePass;
+    }
+    fireVisibleSideEffects(field, isVisible);
+    if (isVisible && isAppointmentTypeFiltered(field)) return false;
+    if (isVisible && field.appointment_type && currentPage === "services") {
+      const stored = sessionStorage.getItem("appointment_type");
+      if (!stored) {
+        sessionStorage.setItem("appointment_type", field.appointment_type);
+      }
+    }
+    return isVisible;
+  }
+  function evaluateSimpleRule(targetField, expectedValue) {
+    const currentValue = formValues[targetField] ?? "";
+    if (expectedValue === "*") {
+      return currentValue !== "" && currentValue !== null && currentValue !== void 0;
+    }
+    if (typeof expectedValue === "string" && expectedValue.includes(" OR ")) {
+      const options = expectedValue.split(" OR ").map((s) => s.trim());
+      return options.some((opt) => {
+        if (opt === "*") return currentValue !== "" && currentValue != null;
+        return String(currentValue) === opt;
+      });
+    }
+    return String(currentValue) === String(expectedValue);
+  }
+  function resolveNumericForComparison(fieldName, rawValue) {
+    const field = formFields.find((f) => f.field === fieldName);
+    if (field?.type === "date" && rawValue) {
+      const dateVal = new Date(rawValue);
+      if (isValid(dateVal)) {
+        const today = startOfDay(/* @__PURE__ */ new Date());
+        const target = startOfDay(dateVal);
+        const diffMs = target.getTime() - today.getTime();
+        return Math.round(diffMs / (1e3 * 60 * 60 * 24));
+      }
+    }
+    return Number(rawValue);
+  }
+  function evaluateCustomExpression(fieldName, expression) {
+    const rawValue = formValues[fieldName] ?? "";
+    if (expression === "*") {
+      return rawValue !== "" && rawValue != null;
+    }
+    if (expression.includes(" and ")) {
+      const parts = expression.split(" and ").map((s) => s.trim());
+      return parts.every((part) => evaluateCustomExpression(fieldName, part));
+    }
+    const match2 = expression.trim().match(/^([<>!=]=?)\s*(.+)$/);
+    if (match2) {
+      const [, operator, operand] = match2;
+      const numericValue = resolveNumericForComparison(fieldName, rawValue);
+      const numericOperand = Number(operand.trim());
+      switch (operator) {
+        case "<":
+          return numericValue < numericOperand;
+        case ">":
+          return numericValue > numericOperand;
+        case "<=":
+          return numericValue <= numericOperand;
+        case ">=":
+          return numericValue >= numericOperand;
+        case "==":
+          return String(rawValue) === operand.trim();
+        case "!=":
+          return String(rawValue) !== operand.trim();
+        default:
+          return false;
+      }
+    }
+    return String(rawValue) === expression.trim();
+  }
+  function evaluateCustomCondition(custom) {
+    if (Array.isArray(custom)) {
+      return custom.every((clause) => evaluateClause(clause));
+    }
+    if (typeof custom === "object" && custom !== null) {
+      const entries = Object.entries(custom);
+      return entries.every(
+        ([fieldName, expression]) => evaluateCustomExpression(fieldName, String(expression))
+      );
+    }
+    return false;
+  }
+  function evaluateAndGroup(data) {
+    if (Array.isArray(data)) {
+      return data.every((clause) => evaluateClause(clause));
+    }
+    if (typeof data === "object" && data !== null && "conditions" in data) {
+      const conditions = data.conditions;
+      return conditions.every((condObj) => {
+        const entries = Object.entries(condObj);
+        return entries.every(
+          ([fieldName, expectedValue]) => evaluateSimpleRule(fieldName, String(expectedValue))
+        );
+      });
+    }
+    return false;
+  }
+  function evaluateOrOfAndGroups(data) {
+    if (Array.isArray(data)) {
+      return data.some(
+        (group) => Array.isArray(group) && group.every((clause) => evaluateClause(clause))
+      );
+    }
+    if (typeof data === "object" && data !== null && "groups" in data) {
+      const groups = data.groups;
+      return groups.some((group) => {
+        if (!group.conditions || !Array.isArray(group.conditions)) return false;
+        return group.conditions.every((condObj) => {
+          const entries = Object.entries(condObj);
+          return entries.every(
+            ([fieldName, expectedValue]) => evaluateSimpleRule(fieldName, String(expectedValue))
+          );
+        });
+      });
+    }
+    return false;
+  }
+  function evaluateOrGroup(clauses) {
+    return clauses.some((clause) => evaluateClause(clause));
+  }
+  function evaluateClause(clause) {
+    const rawValue = formValues[clause.field] ?? "";
+    const operator = clause.operator ?? "==";
+    if (clause.value === "*") {
+      return rawValue !== "" && rawValue != null;
+    }
+    switch (operator) {
+      case "==":
+        return String(rawValue) === String(clause.value);
+      case "!=":
+        return String(rawValue) !== String(clause.value);
+      case ">":
+        return Number(rawValue) > Number(clause.value);
+      case "<":
+        return Number(rawValue) < Number(clause.value);
+      case ">=":
+        return Number(rawValue) >= Number(clause.value);
+      case "<=":
+        return Number(rawValue) <= Number(clause.value);
+      default:
+        return false;
+    }
+  }
+  function checkAllLookupsSuccessful(excludeFieldName) {
+    const allLookupFields = formFields.filter(
+      (f) => f.lookup?.aws_table && f.page === currentPage
+    );
+    const visibleLookupFields = allLookupFields.filter(
+      (f) => (f.visible === true || f.is_visible === true) && f.field !== excludeFieldName
+    );
+    if (visibleLookupFields.length === 0) return false;
+    return visibleLookupFields.every((f) => f.lookupSuccess === true);
+  }
+  function resolveDynamicTitle(field) {
+    const TOKEN_REGEX = /\{([^}]+)\}/g;
+    field.rendered_title = field.title.replace(TOKEN_REGEX, (_, fieldName) => {
+      const value = formValues[fieldName];
+      return value != null && value !== "" ? String(value) : "";
+    });
+  }
+  function isAppointmentTypeFiltered(field) {
+    if (currentPage !== "booking-details") return false;
+    if (!field.appointment_type) return false;
+    const storedType = sessionStorage.getItem("appointment_type");
+    if (!storedType) return false;
+    return field.appointment_type !== storedType;
+  }
+  function evaluateLegacyConditional(field) {
+    if (!field.conditional) {
+      resolveDynamicTitle(field);
+      fireVisibleSideEffects(field, true);
+      return true;
+    }
+    if (!field.trigger || !field.trigger_value) {
+      return true;
+    }
+    const triggerFields = field.trigger.split("|");
+    const triggerExpressions = String(field.trigger_value).split("|");
+    const results = [];
+    triggerFields.forEach((triggerFieldName, i) => {
+      const expression = triggerExpressions[i] ?? "";
+      const parts = expression.split("&");
+      for (const part of parts) {
+        const trimmedPart = part.trim();
+        const parentValue = formValues[triggerFieldName] ?? "";
+        if (trimmedPart === "*") {
+          results.push(parentValue !== "" && parentValue != null && parentValue !== void 0);
+          continue;
+        }
+        const firstChar = trimmedPart[0];
+        if (["<", ">", "!"].includes(firstChar)) {
+          const operand = Number(trimmedPart.substring(1));
+          const numericParentValue = Number(parentValue);
+          switch (firstChar) {
+            case "<":
+              if (numericParentValue < operand) results.push(true);
+              break;
+            case ">":
+              if (numericParentValue > operand) results.push(true);
+              break;
+            case "!":
+              if (String(parentValue) !== String(operand)) results.push(true);
+              break;
+          }
+        } else {
+          results.push(String(parentValue) === String(trimmedPart));
+        }
+      }
+    });
+    const isVisible = results.filter(Boolean).length >= 1;
+    fireVisibleSideEffects(field, isVisible);
+    return isVisible;
+  }
+  const BOOKER_FIELD_KEYS = [
+    "booker_first_name",
+    "booker_last_name",
+    "booker_email",
+    "booker_phone"
+  ];
+  function fireVisibleSideEffects(field, isVisible) {
+    if (isVisible) {
+      handleCompanySet(field);
+      handleServiceSet(field);
+      handleResourceSet(field);
+      handleStaffSet(field);
+      handleAddDuration(field);
+      handleBookerFields(field);
+      handleCopyData(field);
+      handleAppointmentTypeStore(field);
+    } else {
+      handleRemoveDuration(field);
+    }
+  }
+  function handleCompanySet(field) {
+    var _a;
+    if (!field.company_set || !field.company_set.length) return;
+    const formService = (_a = formServicesRef.current)[formId] ?? (_a[formId] = {});
+    if (formService.company_id === field.company_set) return;
+    formService.company_id = field.company_set;
+    field.company_id = field.company_set;
+    onCompanySet?.(field.company_set);
+  }
+  function handleServiceSet(field) {
+    var _a;
+    if (!field.service_set) return;
+    const formService = (_a = formServicesRef.current)[formId] ?? (_a[formId] = {});
+    if (formService.service_id === field.service_set) return;
+    formService.service_id = field.service_set;
+    field.service_id = field.service_set;
+    onServiceSet?.(field.service_set);
+  }
+  function handleResourceSet(field) {
+    var _a;
+    if (!field.resource_set || !field.resource_set.length) return;
+    const formService = (_a = formServicesRef.current)[formId] ?? (_a[formId] = {});
+    if (formService.resource_id === field.resource_set) return;
+    formService.resource_id = field.resource_set;
+    field.resource_id = field.resource_set;
+    onResourceSet?.(field.resource_set);
+  }
+  function handleStaffSet(field) {
+    if (!field.staff_set || !field.staff_set.length) return;
+    onStaffSet?.(field.staff_set);
+  }
+  function handleAddDuration(field) {
+    if (!field.add_duration) return;
+    if (field.duration_added) return;
+    field.duration_added = true;
+    onAddDuration?.(field.add_duration);
+  }
+  function handleRemoveDuration(field) {
+    if (!field.add_duration) return;
+    if (!field.duration_added) return;
+    field.duration_added = false;
+    onAddDuration?.(String(-Number(field.add_duration)));
+  }
+  function handleBookerFields(field) {
+    for (const key of BOOKER_FIELD_KEYS) {
+      const isMarked = field[key] === true || field[key] === "true";
+      if (!isMarked) continue;
+      const value = formValues[field.field];
+      if (value) {
+        onUpdateDatastore?.({ [key]: value });
+      }
+    }
+  }
+  function handleCopyData(field) {
+    const copyData = field.copy_data;
+    if (!copyData?.from || !copyData?.to) return;
+    const currentValue = formValues[field.field] ?? "";
+    let shouldCopy;
+    if (copyData.answer !== void 0 && copyData.answer !== null) {
+      shouldCopy = String(currentValue) === String(copyData.answer);
+    } else {
+      shouldCopy = currentValue !== "" && currentValue != null;
+    }
+    if (!shouldCopy) return;
+    copyData.from.forEach((fromFieldName, index) => {
+      const toFieldName = copyData.to[index];
+      if (!toFieldName) return;
+      const sourceValue = formValues[fromFieldName] ?? getStoredAnswer(formId, fromFieldName);
+      if (sourceValue == null || sourceValue === "") return;
+      if (toFieldName in formValues) {
+        const existingValue = formValues[toFieldName];
+        if (!existingValue) {
+          setFormValues((prev) => ({ ...prev, [toFieldName]: sourceValue }));
+        }
+      }
+      persistAnswer(formId, toFieldName, sourceValue);
+    });
+  }
+  function handleAppointmentTypeStore(field) {
+    if (!field.appointment_type) return;
+    if (currentPage !== "services") return;
+    const existing = sessionStorage.getItem("appointment_type");
+    if (!existing) {
+      sessionStorage.setItem("appointment_type", field.appointment_type);
+    }
+  }
+  async function setExtraItems(field) {
+    if (field.page !== currentPage) return;
+    if (!field.visible && !field.is_visible) return;
+    let extraItemId = field["extra-item"] ?? "";
+    const serviceId = field["service-id"] ?? "";
+    if (field.resource_ids) {
+      const activeResourceId = formServicesRef.current[formId]?.resource_id;
+      if (activeResourceId) {
+        const resourceEntry = field.resource_ids[activeResourceId];
+        if (resourceEntry?.["extra-item"]) {
+          extraItemId = resourceEntry["extra-item"];
+        }
+      }
+    }
+    if (!extraItemId) return;
+    const rawValue = field.type === "heading" ? "1" : formValues[field.field] ?? "0";
+    const numericValue = Number(rawValue);
+    let shouldBeActive;
+    if (isNaN(numericValue)) {
+      const boolResult = evaluateBooleanCondition(rawValue);
+      if (boolResult !== void 0) {
+        shouldBeActive = boolResult;
+      } else {
+        const firstShowKey = field.show ? Object.keys(field.show)[0] : null;
+        shouldBeActive = firstShowKey != null ? String(field.show[firstShowKey]) === String(rawValue) : false;
+      }
+    } else {
+      shouldBeActive = numericValue > 0;
+    }
+    const existingEntry = extraItemsRef.current.find(
+      (item) => item.extraItemId === extraItemId
+    );
+    if (!existingEntry) {
+      if (!shouldBeActive) return;
+      const activeServiceId = formServicesRef.current[formId]?.service_id;
+      if (!activeServiceId) {
+        console.error(
+          "[FormBuilder] Cannot fetch extra item \u2014 no service_id set for form:",
+          formId
+        );
+        return;
+      }
+      if (pendingExtraItemFetchesRef.current.has(extraItemId)) {
+        console.log("[FormBuilder] Skipping duplicate extra item fetch for:", extraItemId);
+        return;
+      }
+      pendingExtraItemFetchesRef.current.add(extraItemId);
+      onProcessing?.(true);
+      const result = await getExtraItemProperties(
+        extraItemId,
+        companyId,
+        activeServiceId,
+        appConfig
+      );
+      pendingExtraItemFetchesRef.current.delete(extraItemId);
+      if (isApiError(result)) {
+        console.error("[FormBuilder] Failed to fetch extra item:", result.message);
+        onProcessing?.(false);
+        return;
+      }
+      const qty = field.type === "heading" ? 1 : numericValue;
+      extraItemsRef.current.push({
+        field: field.field,
+        serviceId,
+        extraItemId,
+        qty
+      });
+      onExtraItemSet?.({
+        item_id: extraItemId,
+        item: { ...result, qty, field: field.field }
+      });
+      onProcessing?.(false);
+    } else if (!shouldBeActive) {
+      extraItemsRef.current = extraItemsRef.current.filter(
+        (item) => item.extraItemId !== extraItemId
+      );
+      onExtraItemSet?.({ item_id: extraItemId, item: null });
+    } else if (existingEntry.qty !== numericValue && field.type !== "heading") {
+      extraItemsRef.current = extraItemsRef.current.filter(
+        (item) => item.extraItemId !== extraItemId
+      );
+      const updatedEntry = {
+        field: field.field,
+        serviceId,
+        extraItemId,
+        qty: numericValue
+      };
+      extraItemsRef.current.push(updatedEntry);
+      onExtraItemChanged?.({ item_id: extraItemId, item: updatedEntry });
+    }
+  }
+  function evaluateBooleanCondition(value) {
+    const normalised = value?.toLowerCase().trim();
+    if (["true", "yes", "1"].includes(normalised)) return true;
+    if (["false", "no", "0", ""].includes(normalised)) return false;
+    return void 0;
+  }
+  const UK_POSTCODE_REGEX = /^([Gg][Ii][Rr] 0[Aa]{2}|((([A-Za-z][0-9]{1,2})|([A-Za-z][A-HJ-Ya-hj-y][0-9]{1,2})|([A-Za-z][0-9][A-Za-z])|([A-Za-z][A-HJ-Ya-hj-y][0-9]?[A-Za-z]))\s?[0-9][A-Za-z]{2}))$/;
+  function isValidUkPostcode(postcode) {
+    return UK_POSTCODE_REGEX.test(postcode.trim());
+  }
+  function updateFieldState(fieldName, updates) {
+    setFormFields(
+      (prev) => prev.map((f) => f.field === fieldName ? { ...f, ...updates } : f)
+    );
+  }
+  async function performAddressLookup(fieldName) {
+    const field = formFields.find((f) => f.field === fieldName);
+    if (!field) return;
+    const postcodeKey = `${fieldName}_postcode`;
+    const postcodeValue = (formValues[postcodeKey] ?? "").trim();
+    updateFieldState(fieldName, { badPostcode: false, addresses: void 0 });
+    if (!postcodeValue) {
+      updateFieldState(fieldName, { badPostcode: true });
+      return;
+    }
+    if (!isValidUkPostcode(postcodeValue)) {
+      console.error(`[FormBuilder] Invalid postcode format for field "${fieldName}": ${postcodeValue}`);
+      updateFieldState(fieldName, { badPostcode: true });
+      return;
+    }
+    updateFieldState(fieldName, { addressLoading: true });
+    onProcessing?.(true);
+    const result = await getAddressLookup(postcodeValue, appConfig);
+    if (isApiError(result)) {
+      console.error("[FormBuilder] Address lookup failed:", result.message);
+      updateFieldState(fieldName, { addressLoading: false, badPostcode: true });
+      onProcessing?.(false);
+      return;
+    }
+    const addresses = result.map((item) => ({
+      address: item.DPA ?? item.LPI ?? { ADDRESS: "" }
+    }));
+    updateFieldState(fieldName, { addressLoading: false, addresses });
+    onProcessing?.(false);
+  }
+  function handleAddressSelected(event, fieldName) {
+    const selectedAddress = event.target.value;
+    setFieldValue(fieldName, selectedAddress);
+    updateFieldState(fieldName, { selected_address: selectedAddress });
+    onAddressSet?.(selectedAddress);
+  }
+  async function performAwsLookup(fieldName) {
+    const field = formFields.find((f) => f.field === fieldName);
+    if (!field?.lookup?.aws_table) return;
+    const lookup = field.lookup;
+    const matchFields = lookup.match ?? [];
+    updateFieldState(fieldName, {
+      lookupError: false,
+      lookupUsed: false,
+      lookupLoading: true,
+      lookupResponse: null,
+      lookupNameMismatch: false
+    });
+    let primaryReference = "";
+    let primaryDynamoField = "";
+    let secondaryReference = "";
+    let secondaryDynamoField = "";
+    for (const match2 of matchFields) {
+      const { form_field, dynamodb_field } = match2;
+      const value = formValues[form_field] ?? getStoredAnswer(formId, form_field) ?? "";
+      if (form_field === fieldName) {
+        primaryReference = value;
+        primaryDynamoField = dynamodb_field;
+      } else if (!secondaryReference) {
+        secondaryReference = value;
+        secondaryDynamoField = dynamodb_field;
+      }
+    }
+    if (!primaryReference) {
+      console.error(`[FormBuilder] No reference value for field "${fieldName}"`);
+      updateFieldState(fieldName, { lookupError: true, lookupLoading: false });
+      return;
+    }
+    const result = await awsLookup(
+      appConfig,
+      lookup.aws_table,
+      primaryDynamoField,
+      primaryReference,
+      secondaryReference || void 0,
+      secondaryDynamoField || void 0
+    );
+    if (isApiError(result)) {
+      console.error(`[FormBuilder] AWS lookup error for field "${fieldName}":`, result.message);
+      updateFieldState(fieldName, { lookupError: true, lookupLoading: false });
+      return;
+    }
+    updateFieldState(fieldName, { lookupLoading: false });
+    if (result.custom_response_code !== 1) {
+      updateFieldState(fieldName, { lookupError: true });
+      return;
+    }
+    if (result.reference?.used === true) {
+      updateFieldState(fieldName, { lookupUsed: true, lookupError: true });
+      return;
+    }
+    if (secondaryReference && secondaryDynamoField === "name" && result.reference?.name) {
+      const responseName = result.reference.name.toLowerCase().trim();
+      const enteredName = secondaryReference.toLowerCase().trim();
+      if (responseName !== enteredName) {
+        updateFieldState(fieldName, { lookupNameMismatch: true, lookupError: true });
+        return;
+      }
+    }
+    const updatedFields = formFields.map((f) => {
+      const isSecondaryMatch = matchFields.some(
+        (m) => m.form_field === f.field && m.form_field !== fieldName
+      );
+      return isSecondaryMatch ? { ...f, lookupValidated: true } : f;
+    });
+    const storedFieldKey = lookup.store_response_field;
+    let resolvedValue;
+    if (storedFieldKey && result.reference?.[storedFieldKey]) {
+      resolvedValue = String(result.reference[storedFieldKey]);
+    } else if (result.reference?.home_office) {
+      resolvedValue = result.reference.home_office;
+    } else {
+      resolvedValue = primaryReference;
+    }
+    setFormFields(
+      updatedFields.map(
+        (f) => f.field === fieldName ? {
+          ...f,
+          lookupSuccess: true,
+          lookupError: false,
+          lookupLoading: false,
+          lookupResponse: result.reference ?? null
+        } : f
+      )
+    );
+    setFieldValue(fieldName, resolvedValue);
+    onAwsLookupSet?.({
+      field: fieldName,
+      reference: result.reference ?? null,
+      success: true
+    });
+    onUpdateDatastore?.({
+      type: "lookupResponse",
+      field: fieldName,
+      lookupResponse: result.reference
+    });
+    refreshVisibility();
+  }
+  function clearAwsLookup(fieldName) {
+    const field = formFields.find((f) => f.field === fieldName);
+    if (!field) return;
+    const matchFields = field.lookup?.match ?? [];
+    const updatedFields = formFields.map((f) => {
+      const isSecondaryMatch = matchFields.some(
+        (m) => m.form_field === f.field && m.form_field !== fieldName
+      );
+      if (isSecondaryMatch) {
+        return { ...f, lookupValidated: false };
+      }
+      if (f.field === fieldName) {
+        return {
+          ...f,
+          lookupError: false,
+          lookupUsed: false,
+          lookupLoading: false,
+          lookupResponse: null,
+          lookupSuccess: false,
+          lookupNameMismatch: false
+        };
+      }
+      return f;
+    });
+    setFormFields(updatedFields);
+    const secondaryMatchFieldNames = matchFields.filter((m) => m.form_field !== fieldName).map((m) => m.form_field);
+    setFormValues((prev) => {
+      const next = { ...prev };
+      for (const name of secondaryMatchFieldNames) {
+        next[name] = "";
+      }
+      return next;
+    });
+    setFieldValue(fieldName, "");
+    onAwsLookupSet?.({ field: fieldName, reference: null, success: false });
+  }
+  const VENUE_SEARCH_DEBOUNCE_MS = 500;
+  async function handleVenueSearchInput(event, field) {
+    const IGNORED_KEYS = /* @__PURE__ */ new Set([
+      "ArrowUp",
+      "ArrowDown",
+      "Enter",
+      "Escape",
+      "Tab",
+      "Shift",
+      "Control",
+      "Alt",
+      "Meta"
+    ]);
+    if (IGNORED_KEYS.has(event.key)) return;
+    updateFieldState(field.field, {
+      selected_resource: void 0,
+      searching: true,
+      noResults: false,
+      answer: void 0
+    });
+    if (venueSearchTimerRef.current) {
+      clearTimeout(venueSearchTimerRef.current);
+    }
+    venueSearchTimerRef.current = setTimeout(async () => {
+      const query = event.target.value.trim();
+      setSearchText(query);
+      if (!query) {
+        setSuggestions([]);
+        updateFieldState(field.field, { searching: false });
+        return;
+      }
+      try {
+        const result = await searchVenue(companyId, query, appConfig);
+        if (isApiError(result)) {
+          console.error("[FormBuilder] Venue search failed:", result.message);
+          updateFieldState(field.field, { searching: false, noResults: true });
+          setSuggestions([]);
+          return;
+        }
+        let venues = result;
+        if (field.filter_by) {
+          const filterValue = (formValues[field.filter_by] ?? "").toLowerCase().trim();
+          if (filterValue) {
+            venues = venues.filter(
+              (v) => v.venue_type?.toLowerCase().trim() === filterValue
+            );
+          }
+        }
+        setSuggestions(venues);
+        updateFieldState(field.field, {
+          searching: false,
+          noResults: venues.length === 0
+        });
+      } catch (err) {
+        console.error("[FormBuilder] Venue search error:", err);
+        setSuggestions([]);
+        updateFieldState(field.field, { searching: false, noResults: true });
+      }
+    }, VENUE_SEARCH_DEBOUNCE_MS);
+  }
+  function selectVenueSuggestion(suggestion, field) {
+    setSuggestions([]);
+    const displayName = suggestion.pretty_name ?? suggestion.venue_name;
+    setSearchText(displayName);
+    updateFieldState(field.field, {
+      selected_resource: suggestion,
+      answer: displayName,
+      searching: false,
+      noResults: false
+    });
+    setFieldValue(field.field, displayName);
+    onVenueSet?.({
+      venue: suggestion,
+      field: field.field,
+      companyId: suggestion.company_id,
+      resourceId: suggestion.resource_id
+    });
+  }
+  function clearVenueSearch(field) {
+    if (venueSearchTimerRef.current) {
+      clearTimeout(venueSearchTimerRef.current);
+    }
+    setSearchText("");
+    setSuggestions([]);
+    updateFieldState(field.field, {
+      selected_resource: void 0,
+      searching: false,
+      noResults: false,
+      answer: void 0
+    });
+    setFieldValue(field.field, "");
+    onVenueSet?.({ venue: null, field: field.field });
+  }
+  function handleFieldChange(fieldName, value) {
+    setFormValues((prev) => ({ ...prev, [fieldName]: value }));
+    persistAnswer(formId, fieldName, value);
+  }
+  const formErrors = {};
+  for (const field of formFields) {
+    if (field.page !== currentPage) continue;
+    if (!field.visible && !field.is_visible) continue;
+    const value = formValues[field.field] ?? "";
+    const error = validateField(field, value);
+    if (error) formErrors[field.field] = true;
+  }
+  function getFieldWrapperClassName(field) {
+    const classes = ["govuk-form-group"];
+    const isInvalid = shouldShowError(field.field) && validateField(field, formValues[field.field] ?? "") != null;
+    if (isInvalid) {
+      classes.push("govuk-form-group--error");
+    }
+    const isHidden = field.hidden_field || field.rules_count > 0 && !field.is_visible || field.lookupValidated;
+    if (isHidden) {
+      classes.push("hidden-field");
+    }
+    return classes.join(" ");
+  }
+  function renderLabel(field) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "govuk-label-wrapper", children: /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "govuk-label govuk-label--m", htmlFor: field.field, children: [
+      field.rendered_title ?? field.title,
+      field.required && " *"
+    ] }) });
+  }
+  function renderHint(field) {
+    if (!field.helptext) return null;
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { id: `${field.field}-hint`, className: "govuk-hint", dangerouslySetInnerHTML: { __html: field.helptext } });
+  }
+  function renderErrors(field) {
+    if (!shouldShowError(field.field)) return null;
+    const error = validateField(field, formValues[field.field] ?? "");
+    if (!error) return null;
+    return /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "govuk-error-message", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "govuk-visually-hidden", children: "Error:" }),
+      getErrorMessage(error)
+    ] });
+  }
+  function renderField(field) {
+    switch (field.type) {
+      case "text":
+      case "number":
+      case "email":
+      case "date":
+        return renderTextualField(field);
+      case "textarea":
+        return renderTextarea(field);
+      case "radio":
+        return renderRadio(field);
+      case "checkbox":
+        return renderCheckbox(field);
+      case "dropdown":
+        return renderDropdown(field);
+      case "heading":
+        return renderHeading(field);
+      case "submit":
+        return renderSubmitField(field);
+      default:
+        return null;
+    }
+  }
+  function renderTextualField(field) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      renderLabel(field),
+      renderHint(field),
+      renderErrors(field),
+      field.address_lookup ? renderAddressLookup(field) : field.lookup?.aws_table ? renderAwsLookup(field) : field.resource_lookup ? renderVenueSearch(field) : renderPlainInput(field)
+    ] });
+  }
+  function renderPlainInput(field) {
+    const isError = shouldShowError(field.field) && validateField(field, formValues[field.field] ?? "") != null;
+    const inputProps = {
+      id: field.field,
+      type: getInputType(field),
+      "aria-required": field.required,
+      value: formValues[field.field] ?? "",
+      className: ["govuk-input", isError ? "govuk-input--error" : ""].join(" ").trim(),
+      onChange: (e) => {
+        handleFieldChange(field.field, e.target.value);
+        markAsDirty(field.field);
+      },
+      onBlur: () => markAsTouched(field.field)
+    };
+    if (field.type === "date" && field.hide_dates_in_future) {
+      inputProps.max = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx("input", { ...inputProps });
+  }
+  function renderTextarea(field) {
+    const isError = shouldShowError(field.field) && validateField(field, formValues[field.field] ?? "") != null;
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      renderLabel(field),
+      renderHint(field),
+      renderErrors(field),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "textarea",
+        {
+          id: field.field,
+          className: ["govuk-textarea", isError ? "govuk-textarea--error" : ""].join(" ").trim(),
+          rows: 5,
+          "aria-required": field.required,
+          value: formValues[field.field] ?? "",
+          onChange: (e) => {
+            handleFieldChange(field.field, e.target.value);
+            markAsDirty(field.field);
+          },
+          onBlur: () => markAsTouched(field.field)
+        }
+      )
+    ] });
+  }
+  function renderRadio(field) {
+    const isError = shouldShowError(field.field) && validateField(field, formValues[field.field] ?? "") != null;
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "govuk-form-group", children: /* @__PURE__ */ jsxRuntime.jsxs("fieldset", { className: "govuk-fieldset", "aria-required": field.required, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("legend", { className: "govuk-fieldset__legend govuk-fieldset__legend--m govuk-fieldset__legend--m-inverse", children: [
+        field.rendered_title ?? field.title,
+        field.required && " *"
+      ] }),
+      renderHint(field),
+      isError && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "govuk-error-message", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "govuk-visually-hidden", children: "Error:" }),
+        getErrorMessage(validateField(field, formValues[field.field] ?? ""))
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "govuk-radios", children: (field.radio_options ?? []).map((option) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "govuk-radios__item", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            className: "govuk-radios__input",
+            type: "radio",
+            id: `${field.field}_${option.value}`,
+            name: field.field,
+            value: option.value,
+            checked: formValues[field.field] === option.value,
+            onChange: () => {
+              handleFieldChange(field.field, option.value);
+              markAsDirty(field.field);
+              markAsTouched(field.field);
+            }
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("label", { className: "govuk-label govuk-radios__label", htmlFor: `${field.field}_${option.value}`, children: option.title })
+      ] }, option.value)) })
+    ] }) });
+  }
+  function renderCheckbox(field) {
+    const isError = shouldShowError(field.field) && validateField(field, formValues[field.field] ?? "") != null;
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "govuk-form-group", children: [
+      renderHint(field),
+      isError && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "govuk-error-message", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "govuk-visually-hidden", children: "Error:" }),
+        "This field is required."
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "govuk-checkboxes", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "govuk-checkboxes__item", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            className: "govuk-checkboxes__input",
+            id: field.field,
+            type: "checkbox",
+            checked: formValues[field.field] === "true",
+            onChange: (e) => {
+              handleFieldChange(field.field, String(e.target.checked));
+              markAsDirty(field.field);
+              markAsTouched(field.field);
+            }
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "govuk-label govuk-checkboxes__label govuk-label--m--inverse", htmlFor: field.field, children: [
+          field.rendered_title ?? field.title,
+          field.required && " *"
+        ] })
+      ] }) })
+    ] });
+  }
+  function renderDropdown(field) {
+    const isError = shouldShowError(field.field) && validateField(field, formValues[field.field] ?? "") != null;
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      renderLabel(field),
+      renderHint(field),
+      renderErrors(field),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "select",
+        {
+          id: field.field,
+          className: ["govuk-select govuk-select--inverse", isError ? "govuk-select--error" : ""].join(" ").trim(),
+          "aria-required": field.required ? "true" : void 0,
+          value: formValues[field.field] ?? "",
+          onChange: (e) => {
+            handleFieldChange(field.field, e.target.value);
+            markAsDirty(field.field);
+            markAsTouched(field.field);
+          },
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: "Please select" }),
+            (field.options ?? []).filter((opt) => opt.visible).map((opt) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: opt.value, children: opt.title }, opt.value))
+          ]
+        }
+      )
+    ] });
+  }
+  function renderHeading(field) {
+    const componentType = field.component_type;
+    if (componentType === "govbook-warning_box") {
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "warning-box", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "content", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "warning-box__title", children: field.rendered_title ?? field.title }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "warning-box__message", dangerouslySetInnerHTML: { __html: field.component_text ?? "" } })
+      ] }) });
+    }
+    if (componentType === "govbook-information_box") {
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "information-box", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "content", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "information-box__title", children: field.rendered_title ?? field.title }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "information-box__message", dangerouslySetInnerHTML: { __html: field.component_text ?? "" } })
+      ] }) });
+    }
+    if (componentType === "body") {
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "govuk-body govuk-body--inverse", dangerouslySetInnerHTML: { __html: field.component_text ?? "" } });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "govuk-heading-m govuk-heading-m--inverse", children: field.rendered_title ?? field.title }),
+      renderHint(field)
+    ] });
+  }
+  function renderSubmitField(field) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      renderHint(field),
+      showSubmit && /* @__PURE__ */ jsxRuntime.jsx("div", { children: /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "nhsuk-button govuk-button", onClick: handleSubmit, children: field.rendered_title ?? field.title }) })
+    ] });
+  }
+  function renderAddressLookup(field) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "address-lookup", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "govuk-input__wrapper", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "govuk-form-group", children: /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            id: `${field.field}_postcode`,
+            type: "text",
+            value: formValues[`${field.field}_postcode`] ?? "",
+            onChange: (e) => handleFieldChange(`${field.field}_postcode`, e.target.value),
+            className: ["govuk-input", field.badPostcode ? "govuk-input--error" : ""].join(" ").trim()
+          }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: "govuk-button govuk-button--secondary",
+            disabled: field.addressLoading,
+            onClick: () => performAddressLookup(field.field),
+            children: field.addressLoading ? "Searching..." : "Find address"
+          }
+        )
+      ] }),
+      field.badPostcode && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "govuk-error-message", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "govuk-visually-hidden", children: "Error:" }),
+        "Please enter a valid UK postcode."
+      ] }),
+      field.addresses && field.addresses.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "govuk-form-group", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("label", { className: "govuk-label", htmlFor: `${field.field}_select`, children: "Select address below" }),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "select",
+          {
+            id: `${field.field}_select`,
+            className: "govuk-select",
+            onChange: (e) => handleAddressSelected(e, field.field),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: "Select address" }),
+              field.addresses.map((item, idx) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: item.address.ADDRESS, children: item.address.ADDRESS }, idx))
+            ]
+          }
+        )
+      ] })
+    ] });
+  }
+  function renderAwsLookup(field) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "aws-lookup", children: [
+      !field.lookupSuccess && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "govuk-input__wrapper", children: /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            id: field.field,
+            type: field.type,
+            "aria-required": field.required,
+            value: formValues[field.field] ?? "",
+            onChange: (e) => handleFieldChange(field.field, e.target.value),
+            className: ["govuk-input", field.lookupError || formErrors[field.field] ? "govuk-input--error" : ""].join(" ").trim()
+          }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "govuk-button-group", children: /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: "govuk-button govuk-button--secondary lookup-reference",
+            disabled: field.lookupLoading,
+            onClick: () => performAwsLookup(field.field),
+            children: field.lookupLoading ? "Checking..." : "Check reference"
+          }
+        ) })
+      ] }),
+      field.lookupLoading && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "govuk-hint", children: "Checking reference..." }),
+      field.lookupError && !field.lookupUsed && !field.lookupNameMismatch && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "govuk-error-message", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "govuk-visually-hidden", children: "Error:" }),
+        "Reference not found. Please check and try again."
+      ] }),
+      field.lookupUsed && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "govuk-error-message", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "govuk-visually-hidden", children: "Error:" }),
+        "This reference has already been used."
+      ] }),
+      field.lookupNameMismatch && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "govuk-error-message", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "govuk-visually-hidden", children: "Error:" }),
+        "The name does not match the reference. Please check and try again."
+      ] }),
+      field.lookupSuccess && field.lookupResponse && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "govuk-inset-text", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "govuk-body", children: /* @__PURE__ */ jsxRuntime.jsx("strong", { children: "Reference verified" }) }),
+        field.lookupResponse.name && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "govuk-body", children: [
+          "Name: ",
+          field.lookupResponse.name
+        ] }),
+        field.lookupResponse.home_office && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "govuk-body", children: [
+          "Reference: ",
+          field.lookupResponse.home_office
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "govuk-button govuk-button--secondary", onClick: () => clearAwsLookup(field.field), children: "Clear" })
+      ] })
+    ] });
+  }
+  function renderVenueSearch(field) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "govuk-form-group resource-lookup", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "govuk-input__wrapper", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            id: field.field,
+            type: "text",
+            className: "govuk-input govuk-input--with-clear",
+            value: searchText,
+            placeholder: "Start typing to search...",
+            autoComplete: "off",
+            onChange: () => {
+            },
+            onKeyDown: (e) => handleVenueSearchInput(e, field)
+          }
+        ),
+        searchText && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            role: "button",
+            tabIndex: 0,
+            className: "govuk-input__suffix",
+            "aria-label": "Clear search",
+            onClick: () => clearVenueSearch(field),
+            onKeyDown: (e) => {
+              if (e.key === "Enter" || e.key === " ") clearVenueSearch(field);
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsx("b", { "aria-hidden": "true", children: "\xD7" })
+          }
+        )
+      ] }),
+      field.searching && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "govuk-hint", children: "Searching\u2026" }),
+      field.noResults && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "govuk-hint", children: "No results found" }),
+      suggestions.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "resource-suggestions", role: "listbox", children: suggestions.map((suggestion, idx) => /* @__PURE__ */ jsxRuntime.jsx(
+        "li",
+        {
+          role: "option",
+          tabIndex: 0,
+          className: "resource-suggestion",
+          onClick: () => selectVenueSuggestion(suggestion, field),
+          onKeyDown: (e) => {
+            if (e.key === "Enter") selectVenueSuggestion(suggestion, field);
+          },
+          children: suggestion.pretty_name ?? suggestion.venue_name
+        },
+        idx
+      )) }),
+      field.answer && field.selected_resource?.description && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "selected-venue-detail", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "govuk-label govuk-fieldset__legend--m pt-3", children: "Description" }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { children: field.selected_resource.description }),
+        field.selected_resource.image && /* @__PURE__ */ jsxRuntime.jsx("img", { className: "selected-venue", src: field.selected_resource.image, alt: "" })
+      ] })
+    ] });
+  }
+  function handleSubmit() {
+    const isFormValid = formFields.filter((f) => f.show_on_this_page && (f.visible || f.is_visible)).every((f) => validateField(f, formValues[f.field] ?? "") === null);
+    if (!isFormValid) {
+      markAllAsTouched();
+      return;
+    }
+    onFormSubmit?.(formValues);
+    onSchema?.(schema);
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "govuk-body", children: "Loading form..." });
+  }
+  if (!formFields.length) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("form", { className: "govuk-form", onSubmit: (e) => {
+    e.preventDefault();
+    handleSubmit();
+  }, children: [
+    formFields.filter((field) => field.show_on_this_page).map((field, index) => /* @__PURE__ */ jsxRuntime.jsx("div", { className: getFieldWrapperClassName(field), children: (field.is_visible || !field.rules_count) && renderField(field) }, field.field || index)),
+    showSubmit && /* @__PURE__ */ jsxRuntime.jsx("button", { type: "submit", className: "nhsuk-button govuk-button", children: "Continue" })
+  ] });
+}
+
 exports.BookingForm = BookingForm;
 exports.ContactDetailsForm = ContactDetailsForm;
 exports.RegistrationForm = RegistrationForm;
 exports.ResetPasswordForm = ResetPasswordForm;
+exports.SchemaFormBuilder = SchemaFormBuilder;
 exports.compose = compose;
 exports.email = email;
+exports.hydrateField = hydrateField;
 exports.minLen = minLen;
 exports.phone = phone;
 exports.required = required;