@rjsf/daisyui 6.0.0-beta.2

package/dist/chakra-ui.umd.js

@@ -0,0 +1,2011 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@rjsf/core'), require('react'), require('@rjsf/utils'), require('react/jsx-runtime'), require('@fortawesome/fontawesome-svg-core'), require('@fortawesome/free-solid-svg-icons'), require('@fortawesome/react-fontawesome'), require('date-fns'), require('react-day-picker'), require('react-day-picker/dist/style.css')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@rjsf/core', 'react', '@rjsf/utils', 'react/jsx-runtime', '@fortawesome/fontawesome-svg-core', '@fortawesome/free-solid-svg-icons', '@fortawesome/react-fontawesome', 'date-fns', 'react-day-picker', 'react-day-picker/dist/style.css'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/chakra-ui"] = {}, global.core, global.react, global.utils, global.jsxRuntime, global.fontawesomeSvgCore, global.freeSolidSvgIcons, global.reactFontawesome, global.dateFns, global.reactDayPicker));
+})(this, (function (exports, core, react, utils, jsxRuntime, fontawesomeSvgCore, freeSolidSvgIcons, reactFontawesome, dateFns, reactDayPicker) { 'use strict';
+
+  // src/index.ts
+  function ArrayFieldItemButtonsTemplate(props) {
+    const {
+      disabled,
+      hasCopy,
+      hasMoveDown,
+      hasMoveUp,
+      hasRemove,
+      idSchema,
+      index,
+      onCopyIndexClick,
+      onDropIndexClick,
+      onReorderClick,
+      readonly,
+      registry,
+      uiSchema
+    } = props;
+    const { CopyButton: CopyButton2, MoveDownButton: MoveDownButton2, MoveUpButton: MoveUpButton2, RemoveButton: RemoveButton2 } = registry.templates.ButtonTemplates;
+    const onCopyClick = react.useMemo(() => onCopyIndexClick(index), [index, onCopyIndexClick]);
+    const onRemoveClick = react.useMemo(() => onDropIndexClick(index), [index, onDropIndexClick]);
+    const onArrowUpClick = react.useMemo(() => onReorderClick(index, index - 1), [index, onReorderClick]);
+    const onArrowDownClick = react.useMemo(() => onReorderClick(index, index + 1), [index, onReorderClick]);
+    const renderMany = [hasMoveUp || hasMoveDown, hasCopy, hasRemove].filter(Boolean).length > 1;
+    const btnClass = renderMany ? "join-item btn btn-sm px-2" : "btn btn-sm px-2 rounded-sm";
+    const removeBtnClass = renderMany ? "join-item btn btn-sm btn-error px-2" : "btn btn-sm btn-error px-2 rounded-sm";
+    const buttons = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      (hasMoveUp || hasMoveDown) && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          MoveUpButton2,
+          {
+            id: utils.buttonId(idSchema, "moveUp"),
+            className: `rjsf-array-item-move-up ${btnClass}`,
+            disabled: disabled || readonly || !hasMoveUp,
+            onClick: onArrowUpClick,
+            uiSchema,
+            registry
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          MoveDownButton2,
+          {
+            id: utils.buttonId(idSchema, "moveDown"),
+            className: `rjsf-array-item-move-down ${btnClass}`,
+            disabled: disabled || readonly || !hasMoveDown,
+            onClick: onArrowDownClick,
+            uiSchema,
+            registry
+          }
+        )
+      ] }),
+      hasCopy && /* @__PURE__ */ jsxRuntime.jsx(
+        CopyButton2,
+        {
+          id: utils.buttonId(idSchema, "copy"),
+          className: `rjsf-array-item-copy ${btnClass}`,
+          disabled: disabled || readonly,
+          onClick: onCopyClick,
+          uiSchema,
+          registry
+        }
+      ),
+      hasRemove && /* @__PURE__ */ jsxRuntime.jsx(
+        RemoveButton2,
+        {
+          id: utils.buttonId(idSchema, "remove"),
+          className: `rjsf-array-item-remove ${removeBtnClass}`,
+          disabled: disabled || readonly,
+          onClick: onRemoveClick,
+          uiSchema,
+          registry
+        }
+      )
+    ] });
+    return renderMany ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "join", children: buttons }) : buttons;
+  }
+  function ArrayFieldItemTemplate(props) {
+    const { children, buttonsProps, hasToolbar, registry, uiSchema, index, totalItems } = props;
+    const uiOptions = utils.getUiOptions(uiSchema);
+    const ArrayFieldItemButtonsTemplate2 = utils.getTemplate(
+      "ArrayFieldItemButtonsTemplate",
+      registry,
+      uiOptions
+    );
+    const isFirstItem = index === 0;
+    const isLastItem = index === totalItems - 1;
+    const borderRadius = isFirstItem ? "rounded-t-lg" : isLastItem ? "rounded-b-lg" : "";
+    const marginBottom = isLastItem ? "" : "mb-[-1px]";
+    const zIndex = index === void 0 ? "" : "z-" + (10 - Math.min(index, 9));
+    return /* @__PURE__ */ jsxRuntime.jsxs("fieldset", { className: `fieldset bg-base-100 border border-base-300 p-4 ${borderRadius} ${marginBottom} ${zIndex}`, children: [
+      children,
+      hasToolbar && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex justify-end mt-2", children: /* @__PURE__ */ jsxRuntime.jsx(ArrayFieldItemButtonsTemplate2, { ...buttonsProps }) })
+    ] });
+  }
+  function ArrayFieldTemplate(props) {
+    const {
+      canAdd,
+      className,
+      disabled,
+      idSchema,
+      items,
+      onAddClick,
+      readonly,
+      registry,
+      required,
+      schema,
+      title,
+      uiSchema
+    } = props;
+    const uiOptions = utils.getUiOptions(uiSchema);
+    const ArrayFieldDescriptionTemplate = utils.getTemplate(
+      "ArrayFieldDescriptionTemplate",
+      registry,
+      uiOptions
+    );
+    const ArrayFieldItemTemplate2 = utils.getTemplate(
+      "ArrayFieldItemTemplate",
+      registry,
+      uiOptions
+    );
+    const ArrayFieldTitleTemplate = utils.getTemplate(
+      "ArrayFieldTitleTemplate",
+      registry,
+      uiOptions
+    );
+    const {
+      ButtonTemplates: { AddButton: AddButton2 }
+    } = registry.templates;
+    const handleAddClick = react.useCallback(
+      (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        onAddClick(e);
+      },
+      [onAddClick]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `array-field-template ${className}`, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ArrayFieldTitleTemplate,
+        {
+          idSchema,
+          title: uiOptions.title || title,
+          schema,
+          uiSchema,
+          required,
+          registry
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ArrayFieldDescriptionTemplate,
+        {
+          idSchema,
+          description: uiOptions.description || schema.description,
+          schema,
+          uiSchema,
+          registry
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "rjsf-array-item-list", children: [
+          items && items.map(({ key, ...itemProps }, index) => /* @__PURE__ */ jsxRuntime.jsx(ArrayFieldItemTemplate2, { ...itemProps, index, totalItems: items.length }, key)),
+          items && items.length === 0 && canAdd && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-center italic text-base-content/70", children: utils.TranslatableString.EmptyArray })
+        ] }),
+        canAdd && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex justify-end", children: /* @__PURE__ */ jsxRuntime.jsx(
+          AddButton2,
+          {
+            id: utils.buttonId(idSchema, "add"),
+            className: "rjsf-array-item-add btn btn-primary btn-sm",
+            onClick: handleAddClick,
+            disabled: disabled || readonly,
+            uiSchema,
+            registry
+          }
+        ) })
+      ] })
+    ] });
+  }
+  function BaseInputTemplate(props) {
+    const {
+      id,
+      value,
+      required,
+      disabled,
+      readonly,
+      autofocus,
+      onChange,
+      onBlur,
+      onFocus,
+      onChangeOverride,
+      options,
+      schema,
+      type,
+      label,
+      placeholder
+    } = props;
+    const inputProps = utils.getInputProps(schema, type, options);
+    const { step, min, max, accept, ...rest } = inputProps;
+    const htmlInputProps = { step, min, max, accept, ...schema.examples ? { list: utils.examplesId(id) } : void 0 };
+    const _onChange = react.useCallback(
+      ({ target: { value: value2 } }) => onChange(value2 === "" ? options.emptyValue : value2),
+      [onChange, options]
+    );
+    const _onBlur = react.useCallback(
+      ({ target }) => onBlur && onBlur(id, target.value),
+      [onBlur, id]
+    );
+    const _onFocus = react.useCallback(
+      ({ target }) => onFocus && onFocus(id, target.value),
+      [onFocus, id]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-control", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: id, className: "label hidden", style: { display: "none" }, children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "label-text", children: label }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            id,
+            name: id,
+            value: value || value === 0 ? value : "",
+            placeholder,
+            required,
+            disabled: disabled || readonly,
+            autoFocus: autofocus,
+            className: "input input-bordered",
+            ...rest,
+            ...htmlInputProps,
+            onChange: onChangeOverride || _onChange,
+            onBlur: _onBlur,
+            onFocus: _onFocus,
+            "aria-describedby": utils.ariaDescribedByIds(id, !!schema.examples)
+          }
+        )
+      ] }),
+      Array.isArray(schema.examples) && /* @__PURE__ */ jsxRuntime.jsx("datalist", { id: utils.examplesId(id), children: schema.examples.concat(schema.default && !schema.examples.includes(schema.default) ? [schema.default] : []).map((example) => {
+        return /* @__PURE__ */ jsxRuntime.jsx("option", { value: example }, example);
+      }) })
+    ] });
+  }
+  function DaisyUIButton(props) {
+    const { icon, iconType, uiSchema, registry, className, ...otherProps } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className, "aria-label": props.title, ...otherProps, children: /* @__PURE__ */ jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, { icon, className: "h-5 w-5" }) });
+  }
+  DaisyUIButton.displayName = "DaisyUIButton";
+  var DaisyUIButton_default = react.memo(DaisyUIButton);
+  fontawesomeSvgCore.library.add(freeSolidSvgIcons.faPlus, freeSolidSvgIcons.faCopy, freeSolidSvgIcons.faArrowDown, freeSolidSvgIcons.faArrowUp, freeSolidSvgIcons.faTrash);
+  function AddButton({
+    className,
+    onClick,
+    disabled,
+    registry,
+    ...otherProps
+  }) {
+    const { translateString } = registry;
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "row", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: `col-xs-3 col-xs-offset-9 text-right ${className}`, children: /* @__PURE__ */ jsxRuntime.jsx(
+      DaisyUIButton_default,
+      {
+        ...otherProps,
+        iconType: "info",
+        icon: freeSolidSvgIcons.faPlus,
+        className: "btn-add col-xs-12 btn-primary btn-primary-content",
+        title: translateString(utils.TranslatableString.AddButton),
+        onClick,
+        disabled,
+        registry
+      }
+    ) }) });
+  }
+  function SubmitButton({ uiSchema }) {
+    const { submitText, norender, props: submitButtonProps = {} } = utils.getSubmitButtonOptions(uiSchema);
+    if (norender) {
+      return null;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { children: /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "submit",
+        ...submitButtonProps,
+        className: `btn btn-primary btn-primary-content ${submitButtonProps.className || ""}`,
+        children: submitText
+      }
+    ) });
+  }
+  function CopyButton(props) {
+    const {
+      registry: { translateString }
+    } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx(DaisyUIButton_default, { ...props, title: translateString(utils.TranslatableString.CopyButton), icon: freeSolidSvgIcons.faCopy });
+  }
+  function MoveDownButton(props) {
+    const {
+      registry: { translateString }
+    } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      DaisyUIButton_default,
+      {
+        ...props,
+        title: translateString(utils.TranslatableString.MoveDownButton),
+        icon: freeSolidSvgIcons.faArrowDown
+      }
+    );
+  }
+  function MoveUpButton(props) {
+    const {
+      registry: { translateString }
+    } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      DaisyUIButton_default,
+      {
+        ...props,
+        title: translateString(utils.TranslatableString.MoveUpButton),
+        icon: freeSolidSvgIcons.faArrowUp
+      }
+    );
+  }
+  function RemoveButton(props) {
+    const {
+      registry: { translateString }
+    } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      DaisyUIButton_default,
+      {
+        ...props,
+        title: translateString(utils.TranslatableString.RemoveButton),
+        iconType: "danger",
+        icon: freeSolidSvgIcons.faTrash
+      }
+    );
+  }
+  function DescriptionField(props) {
+    const { id, description, registry, uiSchema } = props;
+    if (!description) {
+      return null;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { id, className: "description-field my-4", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-base-content/80", children: /* @__PURE__ */ jsxRuntime.jsx(core.RichDescription, { description, registry, uiSchema }) }) });
+  }
+  function ErrorList(props) {
+    const { errors } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "error-list", children: /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "list-disc list-inside text-red-600", children: errors.map((error, index) => /* @__PURE__ */ jsxRuntime.jsx("li", { children: error.stack }, index)) }) });
+  }
+  function FieldErrorTemplate(props) {
+    const { errors } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rjsf-field-error-template text-red-600", children: /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "list-disc list-inside", children: errors?.map((error, index) => /* @__PURE__ */ jsxRuntime.jsx("li", { children: error }, index)) ?? [] }) });
+  }
+  function FieldHelpTemplate(props) {
+    const { help } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rjsf-field-help-template text-gray-500 text-sm", children: /* @__PURE__ */ jsxRuntime.jsx("div", { children: help }) });
+  }
+  function FieldTemplate(props) {
+    const {
+      id,
+      label,
+      children,
+      errors,
+      formContext,
+      formData,
+      help,
+      hideError,
+      displayLabel,
+      classNames,
+      // Destructure props we don't want to pass to div
+      onKeyChange,
+      onDropPropertyClick,
+      uiSchema,
+      schema,
+      readonly,
+      required,
+      rawErrors,
+      rawHelp,
+      rawDescription,
+      hidden,
+      onChange,
+      registry,
+      ...divProps
+    } = props;
+    const isCheckbox = schema.type === "boolean";
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `field-template mb-3 ${classNames || ""}`, ...divProps, children: [
+      displayLabel && !isCheckbox && /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: id, className: "label", children: /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "label-text font-medium", children: [
+        label,
+        required && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-error ml-1", children: "*" })
+      ] }) }),
+      children,
+      errors,
+      help
+    ] });
+  }
+  function GridTemplate(props) {
+    const { children, column, ...rest } = props;
+    if (column) {
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-grow", ...rest, children });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-wrap gap-4", ...rest, children });
+  }
+  function ObjectFieldTemplate(props) {
+    const {
+      description,
+      title,
+      properties,
+      required,
+      disabled,
+      readonly,
+      uiSchema,
+      idSchema,
+      schema,
+      formData,
+      onAddClick,
+      registry
+    } = props;
+    const uiOptions = utils.getUiOptions(uiSchema);
+    const TitleFieldTemplate = utils.getTemplate("TitleFieldTemplate", registry, uiOptions);
+    const DescriptionFieldTemplate = utils.getTemplate(
+      "DescriptionFieldTemplate",
+      registry,
+      uiOptions
+    );
+    const {
+      ButtonTemplates: { AddButton: AddButton2 }
+    } = registry.templates;
+    const isRoot = idSchema.$id === "root";
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `form-control ${isRoot ? "bg-base-100 p-6 rounded-xl shadow-lg" : ""}`, children: [
+      title && /* @__PURE__ */ jsxRuntime.jsx(
+        TitleFieldTemplate,
+        {
+          id: utils.titleId(idSchema),
+          title,
+          required,
+          schema,
+          uiSchema,
+          registry
+        }
+      ),
+      description && /* @__PURE__ */ jsxRuntime.jsx(
+        DescriptionFieldTemplate,
+        {
+          id: utils.descriptionId(idSchema),
+          description,
+          schema,
+          uiSchema,
+          registry
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `grid grid-cols-1 gap-${description ? 3 : 4} ${isRoot ? "" : "mb-4"}`, children: [
+        properties.map(
+          (element, index) => element.hidden ? element.content : /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              className: idSchema.$id === "root" && element.name === "tasks" ? "mt-2" : "",
+              children: element.content
+            },
+            `${idSchema.$id}-${element.name}-${index}`
+          )
+        ),
+        utils.canExpand(schema, uiSchema, formData) && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex justify-end", children: /* @__PURE__ */ jsxRuntime.jsx(
+          AddButton2,
+          {
+            id: utils.buttonId(idSchema, "add"),
+            className: "rjsf-object-property-expand btn btn-primary btn-sm",
+            onClick: onAddClick(schema),
+            disabled: disabled || readonly,
+            uiSchema,
+            registry
+          }
+        ) })
+      ] })
+    ] });
+  }
+  function TitleField(props) {
+    const { id, title, uiSchema } = props;
+    const uiOptions = utils.getUiOptions(uiSchema);
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { id, className: "title-field mb-6", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "text-3xl font-bold text-primary mb-2", children: uiOptions.title || title }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "divider divider-primary" })
+    ] });
+  }
+  function WrapIfAdditionalTemplate(props) {
+    const {
+      children,
+      classNames,
+      disabled,
+      id,
+      label,
+      readonly,
+      required,
+      schema,
+      onKeyChange,
+      onDropPropertyClick,
+      registry,
+      ...rest
+    } = props;
+    const { translateString } = registry;
+    const handleBlur = react.useCallback(
+      (event) => {
+        onKeyChange(event.target.value);
+      },
+      [onKeyChange]
+    );
+    const handleRemove = react.useCallback(() => {
+      onDropPropertyClick(label)();
+    }, [onDropPropertyClick, label]);
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `wrap-if-additional-template ${classNames}`, ...rest, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            type: "text",
+            className: "input input-bordered",
+            id: `${id}-key`,
+            onBlur: handleBlur,
+            defaultValue: label,
+            disabled: disabled || readonly
+          }
+        ),
+        schema.additionalProperties && /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            id: utils.buttonId(id, "remove"),
+            className: "rjsf-array-item-remove btn btn-danger ml-2",
+            onClick: handleRemove,
+            disabled: disabled || readonly,
+            children: translateString(utils.TranslatableString.RemoveButton)
+          }
+        )
+      ] }),
+      children
+    ] });
+  }
+
+  // src/templates/Templates.tsx
+  function generateTemplates() {
+    return {
+      ArrayFieldItemTemplate,
+      ArrayFieldTemplate,
+      ArrayFieldItemButtonsTemplate,
+      BaseInputTemplate,
+      ButtonTemplates: {
+        AddButton,
+        SubmitButton,
+        CopyButton,
+        MoveDownButton,
+        MoveUpButton,
+        RemoveButton
+      },
+      DescriptionFieldTemplate: DescriptionField,
+      ErrorListTemplate: ErrorList,
+      FieldErrorTemplate,
+      FieldHelpTemplate,
+      FieldTemplate,
+      GridTemplate,
+      ObjectFieldTemplate,
+      TitleFieldTemplate: TitleField,
+      WrapIfAdditionalTemplate
+    };
+  }
+  var Templates_default = generateTemplates();
+  function AltDateTimeWidget({
+    time = true,
+    ...props
+  }) {
+    const { AltDateWidget: AltDateWidget2 } = props.registry.widgets;
+    return /* @__PURE__ */ jsxRuntime.jsx(AltDateWidget2, { time, ...props });
+  }
+  var AltDateTimeWidget_default = AltDateTimeWidget;
+  function readyForChange(state, time = false) {
+    return state.year && state.month && state.day && (!time || state.hour && state.minute && state.second);
+  }
+  function getDateElementProps(state, time, yearsRange, format3 = "YMD") {
+    const rangeOptions = yearsRange ?? [1900, (/* @__PURE__ */ new Date()).getFullYear() + 2];
+    const formats = {
+      YMD: ["year", "month", "day"],
+      MDY: ["month", "day", "year"],
+      DMY: ["day", "month", "year"]
+    };
+    const dateElements = formats[format3].map((key) => ({
+      type: key,
+      value: state[key],
+      range: key === "year" ? rangeOptions : key === "month" ? [1, 12] : key === "day" ? [1, 31] : [0, 59]
+    }));
+    if (time) {
+      dateElements.push(
+        { type: "hour", value: state.hour, range: [0, 23] },
+        { type: "minute", value: state.minute, range: [0, 59] },
+        { type: "second", value: state.second, range: [0, 59] }
+      );
+    }
+    return dateElements;
+  }
+  function DateElement({
+    type,
+    range,
+    value,
+    select,
+    rootId,
+    name,
+    disabled,
+    readonly,
+    autofocus,
+    registry,
+    onBlur,
+    onFocus
+  }) {
+    const id = `${rootId}_${type}`;
+    const { SelectWidget: SelectWidget2 } = registry.widgets;
+    const handleChange = react.useCallback(
+      (value2) => {
+        select(type, value2);
+      },
+      [select, type]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      SelectWidget2,
+      {
+        schema: { type: "integer" },
+        id,
+        name,
+        className: "select select-bordered select-sm w-full",
+        options: { enumOptions: utils.dateRangeOptions(range[0], range[1]) },
+        placeholder: type,
+        value,
+        disabled,
+        readonly,
+        autofocus,
+        onChange: handleChange,
+        onBlur,
+        onFocus,
+        registry,
+        label: "",
+        "aria-describedby": utils.ariaDescribedByIds(rootId),
+        required: false
+      }
+    );
+  }
+  function convertToRJSFDateObject(dateObj) {
+    return {
+      year: dateObj.year ? parseInt(dateObj.year) : 0,
+      month: dateObj.month ? parseInt(dateObj.month) : 0,
+      day: dateObj.day ? parseInt(dateObj.day) : 0,
+      hour: dateObj.hour ? parseInt(dateObj.hour) : 0,
+      minute: dateObj.minute ? parseInt(dateObj.minute) : 0,
+      second: dateObj.second ? parseInt(dateObj.second) : 0
+    };
+  }
+  function AltDateWidget({
+    time = false,
+    disabled = false,
+    readonly = false,
+    autofocus = false,
+    options = {},
+    id,
+    name,
+    registry,
+    onBlur,
+    onFocus,
+    onChange,
+    value
+  }) {
+    const { translateString } = registry;
+    const [lastValue, setLastValue] = react.useState(value);
+    const initialState = utils.parseDateString(value, time);
+    const dateReducer = (state2, action) => {
+      return { ...state2, ...action };
+    };
+    const [state, setState] = react.useReducer(dateReducer, initialState);
+    react.useEffect(() => {
+      const rjsfDateObj = convertToRJSFDateObject(state);
+      const stateValue = utils.toDateString(rjsfDateObj, time);
+      if (readyForChange(state, time) && stateValue !== value) {
+        onChange(stateValue);
+      } else if (lastValue !== value) {
+        setLastValue(value);
+        setState(utils.parseDateString(value, time));
+      }
+    }, [time, value, onChange, state, lastValue]);
+    const handleChange = react.useCallback((property, value2) => {
+      setState({ [property]: value2 });
+    }, []);
+    const handleSetNow = react.useCallback(
+      (event) => {
+        event.preventDefault();
+        if (disabled || readonly) {
+          return;
+        }
+        const nextState = utils.parseDateString((/* @__PURE__ */ new Date()).toJSON(), time);
+        const rjsfDateObj = convertToRJSFDateObject(nextState);
+        onChange(utils.toDateString(rjsfDateObj, time));
+      },
+      [disabled, readonly, time, onChange]
+    );
+    const handleClear = react.useCallback(
+      (event) => {
+        event.preventDefault();
+        if (disabled || readonly) {
+          return;
+        }
+        onChange(void 0);
+      },
+      [disabled, readonly, onChange]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grid grid-cols-3 gap-2", children: getDateElementProps(
+        state,
+        time,
+        options.yearsRange,
+        options.format
+      ).map((elemProps, i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-control", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("label", { className: "label", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "label-text capitalize", children: elemProps.type }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          DateElement,
+          {
+            rootId: id,
+            name,
+            select: handleChange,
+            type: elemProps.type,
+            range: elemProps.range,
+            value: elemProps.value,
+            disabled,
+            readonly,
+            registry,
+            onBlur,
+            onFocus,
+            autofocus: autofocus && i === 0
+          }
+        )
+      ] }, i)) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-start space-x-2", children: [
+        (options.hideNowButton !== void 0 ? !options.hideNowButton : true) && /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: "btn btn-sm btn-primary",
+            onClick: handleSetNow,
+            disabled: disabled || readonly,
+            children: translateString(utils.TranslatableString.NowLabel)
+          }
+        ),
+        (options.hideClearButton !== void 0 ? !options.hideClearButton : true) && /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: "btn btn-sm btn-secondary",
+            onClick: handleClear,
+            disabled: disabled || readonly,
+            children: translateString(utils.TranslatableString.ClearLabel)
+          }
+        )
+      ] })
+    ] });
+  }
+  function CheckboxWidget(props) {
+    const {
+      id,
+      value,
+      required,
+      disabled,
+      hideLabel,
+      label,
+      readonly,
+      registry,
+      options,
+      schema,
+      uiSchema,
+      onChange,
+      onFocus,
+      onBlur
+    } = props;
+    const DescriptionFieldTemplate = utils.getTemplate(
+      "DescriptionFieldTemplate",
+      registry,
+      options
+    );
+    const description = options.description || schema.description;
+    const handleFocus = react.useCallback(() => {
+      if (onFocus) {
+        onFocus(id, value);
+      }
+    }, [onFocus, id, value]);
+    const handleBlur = react.useCallback(() => {
+      if (onBlur) {
+        onBlur(id, value);
+      }
+    }, [onBlur, id, value]);
+    const handleChange = react.useCallback(
+      (event) => {
+        onChange(event.target.checked);
+      },
+      [onChange]
+    );
+    const input = /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        type: "checkbox",
+        id,
+        checked: value,
+        required,
+        disabled: disabled || readonly,
+        onChange: handleChange,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        className: "checkbox"
+      }
+    );
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-control", children: [
+      !hideLabel && description && /* @__PURE__ */ jsxRuntime.jsx(
+        DescriptionFieldTemplate,
+        {
+          id: utils.descriptionId(id),
+          description,
+          schema,
+          uiSchema,
+          registry
+        }
+      ),
+      hideLabel || !label ? input : /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "label cursor-pointer justify-start", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mr-2", children: input }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "label-text", children: [
+          label,
+          required && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-error ml-1", children: "*" })
+        ] })
+      ] })
+    ] });
+  }
+  function CheckboxesWidget({
+    id,
+    disabled,
+    options,
+    value,
+    readonly,
+    required,
+    onChange,
+    onFocus,
+    onBlur
+  }) {
+    const { enumOptions } = options;
+    const isEnumeratedObject = enumOptions && enumOptions[0]?.value && typeof enumOptions[0].value === "object";
+    const isChecked = react.useCallback(
+      (option) => {
+        if (!Array.isArray(value)) {
+          return false;
+        }
+        if (isEnumeratedObject) {
+          return value.some((v) => v.name === option.value.name);
+        }
+        return value.includes(option.value);
+      },
+      [value, isEnumeratedObject]
+    );
+    const handleChange = react.useCallback(
+      (event) => {
+        const index = Number(event.target.dataset.index);
+        const option = enumOptions?.[index];
+        if (!option) {
+          return;
+        }
+        const newValue = Array.isArray(value) ? [...value] : [];
+        const optionValue = isEnumeratedObject ? option.value : option.value;
+        if (isChecked(option)) {
+          onChange(newValue.filter((v) => isEnumeratedObject ? v.name !== optionValue.name : v !== optionValue));
+        } else {
+          onChange([...newValue, optionValue]);
+        }
+      },
+      [onChange, value, isChecked, isEnumeratedObject, enumOptions]
+    );
+    const handleFocus = react.useCallback(
+      (event) => {
+        if (onFocus) {
+          const index = Number(event.target.dataset.index);
+          const option = enumOptions?.[index];
+          if (option) {
+            onFocus(id, option.value);
+          }
+        }
+      },
+      [onFocus, id, enumOptions]
+    );
+    const handleBlur = react.useCallback(
+      (event) => {
+        if (onBlur) {
+          const index = Number(event.target.dataset.index);
+          const option = enumOptions?.[index];
+          if (option) {
+            onBlur(id, option.value);
+          }
+        }
+      },
+      [onBlur, id, enumOptions]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "form-control", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col gap-2 mt-1", children: enumOptions?.map((option, index) => /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "flex items-center cursor-pointer gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "checkbox",
+          id: `${id}-${option.value}`,
+          className: "checkbox",
+          name: id,
+          checked: isChecked(option),
+          required,
+          disabled: disabled || readonly,
+          "data-index": index,
+          onChange: handleChange,
+          onFocus: handleFocus,
+          onBlur: handleBlur
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "label-text", children: option.label })
+    ] }, option.value)) }) });
+  }
+  function useDatePickerState(initialDate) {
+    const [isOpen, setIsOpen] = react.useState(false);
+    const [month, setMonth] = react.useState(initialDate ?? /* @__PURE__ */ new Date());
+    return { isOpen, setIsOpen, month, setMonth };
+  }
+  function useClickOutside(ref, callback) {
+    react.useEffect(() => {
+      const handleClickOutside = (event) => {
+        if (ref.current && !ref.current.contains(event.target)) {
+          callback();
+        }
+      };
+      document.addEventListener("mousedown", handleClickOutside);
+      return () => document.removeEventListener("mousedown", handleClickOutside);
+    }, [ref, callback]);
+  }
+  var dayPickerStyles = {
+    classNames: {
+      [reactDayPicker.UI.Root]: "relative",
+      [reactDayPicker.UI.Nav]: "hidden",
+      [reactDayPicker.UI.Chevron]: "hidden",
+      [reactDayPicker.UI.CaptionLabel]: "hidden",
+      [reactDayPicker.UI.Dropdowns]: "flex justify-between gap-4 px-4 pb-4",
+      [reactDayPicker.UI.Dropdown]: "select select-bordered select-sm w-32",
+      [reactDayPicker.UI.MonthsDropdown]: "select select-bordered select-sm",
+      [reactDayPicker.UI.YearsDropdown]: "select select-bordered select-sm",
+      [reactDayPicker.UI.Months]: "flex justify-center",
+      [reactDayPicker.UI.Month]: "w-full",
+      [reactDayPicker.UI.MonthCaption]: "flex justify-center",
+      [reactDayPicker.UI.MonthGrid]: "w-full",
+      [reactDayPicker.UI.Weekdays]: "grid grid-cols-7 text-center border-b mb-2 pb-1 text-base-content/60 uppercase",
+      [reactDayPicker.UI.Weekday]: "p-1 font-medium text-base-content/60 text-sm",
+      [reactDayPicker.UI.Week]: "grid grid-cols-7",
+      [reactDayPicker.UI.Day]: "w-10 h-8 p-0 relative rounded-md",
+      [reactDayPicker.UI.DayButton]: "btn btn-ghost absolute inset-0 flex items-center justify-center w-full h-full cursor-pointer rounded-md hover:btn-primary"
+    },
+    modifiers: {
+      selected: "btn btn-accent min-h-0 h-full",
+      outside: "text-base-content/30 hover:btn-ghost",
+      disabled: "opacity-50 cursor-not-allowed hover:btn-disabled"
+    }
+  };
+  function DateTimePickerPopup({ selectedDate, month, onMonthChange, onSelect, onTimeChange }) {
+    const customDayModifiers = {
+      selected: selectedDate,
+      "custom-today": (date) => dateFns.isToday(date) && !(selectedDate && dateFns.isSameDay(date, selectedDate))
+    };
+    const customModifiersClassNames = {
+      ...dayPickerStyles.modifiers,
+      "custom-today": "btn btn-outline btn-info min-h-0 h-full"
+    };
+    const handleClick = react.useCallback((e) => {
+      e.stopPropagation();
+    }, []);
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactDayPicker.DayPicker,
+        {
+          mode: "single",
+          selected: selectedDate,
+          month,
+          onMonthChange,
+          onSelect,
+          captionLayout: "dropdown",
+          fromYear: 1900,
+          toYear: (/* @__PURE__ */ new Date()).getFullYear() + 10,
+          showOutsideDays: true,
+          classNames: dayPickerStyles.classNames,
+          modifiers: customDayModifiers,
+          modifiersClassNames: customModifiersClassNames
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-3 border-t border-base-300 pt-3", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-control w-full", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("label", { className: "label", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "label-text", children: "Time" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            type: "time",
+            className: "input input-bordered w-full",
+            value: selectedDate ? dateFns.format(selectedDate, "HH:mm") : "",
+            onChange: onTimeChange,
+            onClick: handleClick
+          }
+        )
+      ] }) })
+    ] });
+  }
+  var MemoizedDateTimePickerPopup = react.memo(DateTimePickerPopup);
+  function DateTimeWidget(props) {
+    const { id, value, onChange, onFocus, onBlur, schema } = props;
+    const initialDate = react.useMemo(() => value ? new Date(value) : void 0, [value]);
+    const [localDate, setLocalDate] = react.useState(initialDate);
+    react.useEffect(() => {
+      setLocalDate(initialDate);
+    }, [initialDate]);
+    const { isOpen, setIsOpen, month, setMonth } = useDatePickerState(initialDate);
+    const containerRef = react.useRef(null);
+    const inputRef = react.useRef(null);
+    useClickOutside(containerRef, () => {
+      if (isOpen) {
+        setIsOpen(false);
+        onChange(localDate ? localDate.toISOString() : "");
+        if (onBlur) {
+          onBlur(id, value);
+        }
+      }
+    });
+    react.useEffect(() => {
+      if (localDate) {
+        setMonth(localDate);
+      }
+    }, [localDate, setMonth]);
+    const handleMonthChange = react.useCallback((date) => setMonth(date), [setMonth]);
+    const handleSelect = react.useCallback(
+      (date) => {
+        if (date) {
+          if (localDate) {
+            date.setHours(localDate.getHours(), localDate.getMinutes());
+          }
+          setLocalDate(date);
+        }
+      },
+      [localDate]
+    );
+    const handleTimeChange = react.useCallback(
+      (e) => {
+        if (localDate) {
+          const [hours, minutes] = e.target.value.split(":");
+          const newDate = new Date(localDate);
+          newDate.setHours(parseInt(hours, 10), parseInt(minutes, 10));
+          setLocalDate(newDate);
+        }
+      },
+      [localDate]
+    );
+    const togglePicker = react.useCallback(
+      (e) => {
+        e.stopPropagation();
+        setIsOpen((prev) => !prev);
+        if (!isOpen && onFocus) {
+          onFocus(id, value);
+        }
+      },
+      [isOpen, id, onFocus, setIsOpen, value]
+    );
+    const handleFocus = react.useCallback(() => {
+      if (onFocus) {
+        onFocus(id, value);
+      }
+    }, [id, onFocus, value]);
+    const handleBlur = react.useCallback(() => {
+      if (!isOpen && onBlur) {
+        onBlur(id, value);
+      }
+    }, [id, onBlur, value, isOpen]);
+    const handleKeyDown = react.useCallback(
+      (e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          togglePicker(e);
+        }
+      },
+      [togglePicker]
+    );
+    const handleContainerClick = react.useCallback((e) => {
+      e.stopPropagation();
+    }, []);
+    react.useEffect(() => {
+      const handleEscape = (e) => {
+        if (e.key === "Escape" && isOpen) {
+          setIsOpen(false);
+          if (onBlur) {
+            onBlur(id, value);
+          }
+        }
+      };
+      document.addEventListener("keydown", handleEscape);
+      return () => document.removeEventListener("keydown", handleEscape);
+    }, [id, isOpen, onBlur, value]);
+    const handleDoneClick = react.useCallback(() => {
+      setIsOpen(false);
+      onChange(localDate ? localDate.toISOString() : "");
+      if (onBlur) {
+        onBlur(id, value);
+      }
+      inputRef.current?.focus();
+    }, [localDate, onChange, onBlur, id, value]);
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "form-control my-4 w-full relative", children: /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: "w-full",
+        tabIndex: 0,
+        onKeyDown: handleKeyDown,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        ref: inputRef,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              id,
+              className: `input input-bordered w-full flex items-center justify-between cursor-pointer ${isOpen ? "ring-2 ring-primary/50" : ""}`,
+              onClick: togglePicker,
+              role: "button",
+              "aria-haspopup": "true",
+              "aria-expanded": isOpen,
+              tabIndex: -1,
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: localDate && dateFns.isValid(localDate) ? "" : "text-base-content/50", children: localDate && dateFns.isValid(localDate) ? dateFns.format(localDate, "PP p") : schema.title }),
+                /* @__PURE__ */ jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, { icon: freeSolidSvgIcons.faCalendar, className: "ml-2 h-4 w-4 text-primary" })
+              ]
+            }
+          ),
+          isOpen && /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              ref: containerRef,
+              className: "absolute z-[100] mt-2 w-full max-w-xs bg-base-100 border border-base-300 shadow-lg rounded-box",
+              onClick: handleContainerClick,
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  MemoizedDateTimePickerPopup,
+                  {
+                    selectedDate: localDate,
+                    month,
+                    onMonthChange: handleMonthChange,
+                    onSelect: handleSelect,
+                    onTimeChange: handleTimeChange
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-3 flex justify-end border-t border-base-300", children: /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "btn btn-sm btn-primary", onClick: handleDoneClick, children: "Done" }) })
+              ]
+            }
+          )
+        ]
+      }
+    ) });
+  }
+  function useDatePickerState2(initialDate) {
+    const [isOpen, setIsOpen] = react.useState(false);
+    const [month, setMonth] = react.useState(initialDate ?? /* @__PURE__ */ new Date());
+    return { isOpen, setIsOpen, month, setMonth };
+  }
+  function useClickOutside2(ref, callback) {
+    react.useEffect(() => {
+      const handleClickOutside = (event) => {
+        if (ref.current && !ref.current.contains(event.target)) {
+          callback();
+        }
+      };
+      document.addEventListener("mousedown", handleClickOutside);
+      return () => document.removeEventListener("mousedown", handleClickOutside);
+    }, [ref, callback]);
+  }
+  var dayPickerStyles2 = {
+    classNames: {
+      [reactDayPicker.UI.Root]: "relative",
+      [reactDayPicker.UI.Nav]: "hidden",
+      [reactDayPicker.UI.Chevron]: "hidden",
+      [reactDayPicker.UI.CaptionLabel]: "hidden",
+      [reactDayPicker.UI.Dropdowns]: "flex justify-between gap-4 px-4 pb-4",
+      [reactDayPicker.UI.Dropdown]: "select select-bordered select-sm w-32",
+      [reactDayPicker.UI.MonthsDropdown]: "select select-bordered select-sm",
+      [reactDayPicker.UI.YearsDropdown]: "select select-bordered select-sm",
+      [reactDayPicker.UI.Months]: "flex justify-center",
+      [reactDayPicker.UI.Month]: "w-full",
+      [reactDayPicker.UI.MonthCaption]: "flex justify-center",
+      [reactDayPicker.UI.MonthGrid]: "w-full",
+      [reactDayPicker.UI.Weekdays]: "grid grid-cols-7 text-center border-b mb-2 pb-1 text-base-content/60 uppercase",
+      [reactDayPicker.UI.Weekday]: "p-1 font-medium text-base-content/60 text-sm",
+      [reactDayPicker.UI.Week]: "grid grid-cols-7",
+      [reactDayPicker.UI.Day]: "w-10 h-8 p-0 relative rounded-md",
+      [reactDayPicker.UI.DayButton]: "btn btn-ghost absolute inset-0 flex items-center justify-center w-full h-full cursor-pointer rounded-md hover:btn-primary"
+    },
+    modifiers: {
+      selected: "btn btn-accent min-h-0 h-full",
+      outside: "text-base-content/30 hover:btn-ghost",
+      disabled: "opacity-50 cursor-not-allowed hover:btn-disabled"
+    }
+  };
+  function DatePickerPopup({ selectedDate, month, onMonthChange, onSelect }) {
+    const customDayModifiers = {
+      selected: selectedDate,
+      "custom-today": (date) => dateFns.isToday(date) && !(selectedDate && dateFns.isSameDay(date, selectedDate))
+    };
+    const customModifiersClassNames = {
+      ...dayPickerStyles2.modifiers,
+      "custom-today": "btn btn-outline btn-info min-h-0 h-full"
+    };
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-3", style: { minWidth: "320px", minHeight: "350px" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactDayPicker.DayPicker,
+      {
+        mode: "single",
+        selected: selectedDate,
+        month,
+        onMonthChange,
+        onSelect,
+        captionLayout: "dropdown",
+        fromYear: 1900,
+        toYear: (/* @__PURE__ */ new Date()).getFullYear() + 10,
+        showOutsideDays: true,
+        classNames: dayPickerStyles2.classNames,
+        modifiers: customDayModifiers,
+        modifiersClassNames: customModifiersClassNames
+      }
+    ) });
+  }
+  var MemoizedDatePickerPopup = react.memo(DatePickerPopup);
+  function DateWidget(props) {
+    const { id, value, onChange, onFocus, onBlur, schema } = props;
+    const initialDate = react.useMemo(() => value ? new Date(value) : void 0, [value]);
+    const [localDate, setLocalDate] = react.useState(initialDate);
+    react.useEffect(() => {
+      setLocalDate(initialDate);
+    }, [initialDate]);
+    const { isOpen, setIsOpen, month, setMonth } = useDatePickerState2(initialDate);
+    const containerRef = react.useRef(null);
+    const inputRef = react.useRef(null);
+    useClickOutside2(containerRef, () => {
+      if (isOpen) {
+        setIsOpen(false);
+        onChange(localDate ? localDate.toISOString() : "");
+        if (onBlur) {
+          onBlur(id, value);
+        }
+      }
+    });
+    react.useEffect(() => {
+      if (localDate) {
+        setMonth(localDate);
+      }
+    }, [localDate, setMonth]);
+    const handleMonthChange = react.useCallback((date) => setMonth(date), [setMonth]);
+    const handleSelect = react.useCallback((date) => {
+      if (date) {
+        date.setHours(0, 0, 0, 0);
+        setLocalDate(date);
+      }
+    }, []);
+    react.useEffect(() => {
+      let portalContainer = document.getElementById("date-picker-portal");
+      if (!portalContainer) {
+        portalContainer = document.createElement("div");
+        portalContainer.id = "date-picker-portal";
+        document.body.appendChild(portalContainer);
+      }
+      return () => {
+        const container = document.getElementById("date-picker-portal");
+        if (container && document.querySelectorAll(".date-picker-popup").length === 0) {
+          container.remove();
+        }
+      };
+    }, []);
+    const getDocumentAndWindow = () => {
+      let doc = document;
+      let win = window;
+      try {
+        if (window.frameElement) {
+          const iframe = window.frameElement;
+          if (iframe.contentDocument) {
+            doc = iframe.contentDocument;
+          }
+          if (iframe.contentWindow) {
+            win = iframe.contentWindow;
+          }
+        }
+      } catch (e) {
+        console.log("Unable to access parent frame:", e);
+      }
+      return { doc, win };
+    };
+    const renderCalendar = react.useCallback(() => {
+      if (!containerRef.current || !inputRef.current) {
+        return;
+      }
+      const { win } = getDocumentAndWindow();
+      const inputRect = inputRef.current.getBoundingClientRect();
+      const containerWidth = 320;
+      containerRef.current.style.position = "fixed";
+      containerRef.current.style.top = `${inputRect.bottom + 5}px`;
+      const rightEdge = inputRect.left + containerWidth;
+      const windowWidth = win.innerWidth;
+      if (rightEdge > windowWidth - 20) {
+        containerRef.current.style.left = `${Math.max(20, windowWidth - 20 - containerWidth)}px`;
+      } else {
+        containerRef.current.style.left = `${inputRect.left}px`;
+      }
+      containerRef.current.style.zIndex = "99999";
+    }, [containerRef, inputRef]);
+    react.useEffect(() => {
+      if (!isOpen) {
+        return;
+      }
+      renderCalendar();
+      window.addEventListener("resize", renderCalendar);
+      window.addEventListener("scroll", renderCalendar);
+      return () => {
+        window.removeEventListener("resize", renderCalendar);
+        window.removeEventListener("scroll", renderCalendar);
+      };
+    }, [isOpen, renderCalendar]);
+    const togglePicker = react.useCallback(
+      (e) => {
+        e.stopPropagation();
+        setIsOpen((prev) => !prev);
+        if (!isOpen && onFocus) {
+          onFocus(id, value);
+        }
+      },
+      [isOpen, id, onFocus, setIsOpen, value]
+    );
+    const handleFocus = react.useCallback(() => {
+      if (onFocus) {
+        onFocus(id, value);
+      }
+    }, [id, onFocus, value]);
+    const handleBlur = react.useCallback(() => {
+      if (!isOpen && onBlur) {
+        onBlur(id, value);
+      }
+    }, [id, onBlur, value, isOpen]);
+    react.useEffect(() => {
+      const handleEscape = (e) => {
+        if (e.key === "Escape" && isOpen) {
+          setIsOpen(false);
+          if (onBlur) {
+            onBlur(id, value);
+          }
+        }
+      };
+      document.addEventListener("keydown", handleEscape);
+      return () => document.removeEventListener("keydown", handleEscape);
+    }, [id, isOpen, onBlur, value]);
+    const handleDoneClick = react.useCallback(() => {
+      setIsOpen(false);
+      onChange(localDate ? localDate.toISOString() : "");
+      if (onBlur) {
+        onBlur(id, value);
+      }
+      inputRef.current?.focus();
+    }, [localDate, onChange, onBlur, id, value]);
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "form-control my-4 w-full relative", children: /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: "w-full",
+        tabIndex: 0,
+        onKeyDown: (e) => {
+          if (e.key === "Enter" || e.key === " ") {
+            togglePicker(e);
+          }
+        },
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        ref: inputRef,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              id,
+              className: `input input-bordered w-full flex items-center justify-between cursor-pointer ${isOpen ? "ring-2 ring-primary/50" : ""}`,
+              onClick: togglePicker,
+              role: "button",
+              "aria-haspopup": "true",
+              "aria-expanded": isOpen,
+              tabIndex: -1,
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: localDate && dateFns.isValid(localDate) ? "" : "text-base-content/50", children: localDate && dateFns.isValid(localDate) ? dateFns.format(localDate, "PP") : schema.title }),
+                /* @__PURE__ */ jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, { icon: freeSolidSvgIcons.faCalendar, className: "ml-2 h-4 w-4 text-primary" })
+              ]
+            }
+          ),
+          isOpen && /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              ref: containerRef,
+              className: "date-picker-popup fixed z-[99999] w-full max-w-xs bg-base-100 border border-base-300 shadow-lg rounded-box",
+              style: {
+                maxHeight: "none",
+                overflow: "visible"
+              },
+              onClick: (e) => e.stopPropagation(),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  MemoizedDatePickerPopup,
+                  {
+                    selectedDate: localDate,
+                    month,
+                    onMonthChange: handleMonthChange,
+                    onSelect: handleSelect
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-3 flex justify-end border-t border-base-300", children: /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "btn btn-sm btn-primary", onClick: handleDoneClick, children: "Done" }) })
+              ]
+            }
+          )
+        ]
+      }
+    ) });
+  }
+  function FileWidget(props) {
+    const { id, required, disabled, readonly, schema, onChange, onFocus, onBlur, options = {} } = props;
+    const isMulti = schema.type === "array" || Boolean(options.multiple);
+    const accept = typeof options.accept === "string" ? options.accept : void 0;
+    const handleChange = react.useCallback(
+      (event) => {
+        if (!event.target.files) {
+          return;
+        }
+        const fileList = Array.from(event.target.files);
+        if (isMulti) {
+          onChange(fileList);
+        } else {
+          onChange(fileList[0] || null);
+        }
+      },
+      [onChange, isMulti]
+    );
+    const handleFocus = react.useCallback(
+      (event) => {
+        if (onFocus) {
+          onFocus(id, event.target.files ? Array.from(event.target.files) : null);
+        }
+      },
+      [onFocus, id]
+    );
+    const handleBlur = react.useCallback(
+      (event) => {
+        if (onBlur) {
+          onBlur(id, event.target.files ? Array.from(event.target.files) : null);
+        }
+      },
+      [onBlur, id]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        id,
+        type: "file",
+        className: "file-input w-full",
+        required,
+        disabled: disabled || readonly,
+        onChange: handleChange,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        multiple: isMulti,
+        accept
+      }
+    );
+  }
+  function RadioWidget({
+    id,
+    options,
+    value,
+    required,
+    disabled,
+    readonly,
+    onChange,
+    onFocus,
+    onBlur
+  }) {
+    const { enumOptions } = options;
+    const isEnumeratedObject = enumOptions && enumOptions[0]?.value && typeof enumOptions[0].value === "object";
+    const getValue = (option) => {
+      return option.value;
+    };
+    const isChecked = (option) => {
+      if (isEnumeratedObject) {
+        return value && value.name === option.value.name;
+      }
+      return value === option.value;
+    };
+    const handleFocus = react.useCallback(
+      (event) => {
+        if (onFocus) {
+          const index = Number(event.target.dataset.index);
+          const optionValue = enumOptions?.[index]?.value;
+          onFocus(id, optionValue);
+        }
+      },
+      [onFocus, id, enumOptions]
+    );
+    const handleBlur = react.useCallback(
+      (event) => {
+        if (onBlur) {
+          const index = Number(event.target.dataset.index);
+          const optionValue = enumOptions?.[index]?.value;
+          onBlur(id, optionValue);
+        }
+      },
+      [onBlur, id, enumOptions]
+    );
+    const handleChange = react.useCallback(
+      (event) => {
+        const index = Number(event.target.dataset.index);
+        const option = enumOptions?.[index];
+        if (option) {
+          onChange(isEnumeratedObject ? option.value : option.value);
+          event.target.blur();
+        }
+      },
+      [onChange, isEnumeratedObject, enumOptions]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "form-control", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col gap-2 mt-1", children: enumOptions?.map((option, index) => /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "flex items-center cursor-pointer gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "radio",
+          id: `${id}-${option.value}`,
+          className: "radio",
+          name: id,
+          value: getValue(option),
+          checked: isChecked(option),
+          required,
+          disabled: disabled || readonly,
+          "data-index": index,
+          onChange: handleChange,
+          onFocus: handleFocus,
+          onBlur: handleBlur
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "label-text", children: option.label })
+    ] }, option.value)) }) });
+  }
+  function RangeWidget({
+    id,
+    value,
+    required,
+    disabled,
+    readonly,
+    onChange,
+    onFocus,
+    onBlur,
+    schema
+  }) {
+    const handleFocus = (event) => {
+      if (onFocus) {
+        onFocus(id, event.target.value);
+      }
+    };
+    const handleBlur = (event) => {
+      if (onBlur) {
+        onBlur(id, event.target.value);
+      }
+    };
+    const handleChange = react.useCallback(
+      (event) => {
+        onChange(event.target.value);
+      },
+      [onChange]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "form-control", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "range",
+          id,
+          className: "range",
+          value: value || schema.default,
+          required,
+          disabled: disabled || readonly,
+          min: schema.minimum,
+          max: schema.maximum,
+          step: schema.multipleOf || 1,
+          onChange: handleChange,
+          onFocus: handleFocus,
+          onBlur: handleBlur
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "label-text ml-4", children: value })
+    ] }) });
+  }
+  function RatingWidget({
+    id,
+    value,
+    required,
+    disabled,
+    readonly,
+    autofocus,
+    onChange,
+    onFocus,
+    onBlur,
+    schema,
+    options
+  }) {
+    const { stars = 5, shape = "star", color = "orange", size = "md", colorGradient = false } = options;
+    const numStars = schema.maximum ? Math.min(schema.maximum, 5) : Math.min(Math.max(stars, 1), 5);
+    const min = schema.minimum || 0;
+    const maskClass = shape === "heart" ? "mask-heart" : "mask-star-2";
+    const sizeClass = size === "md" ? "" : `rating-${size}`;
+    const _onChange = react.useCallback(
+      ({ target: { value: value2 } }) => {
+        onChange(parseInt(value2));
+      },
+      [onChange]
+    );
+    const handleFocus = react.useCallback(
+      (event) => {
+        if (onFocus) {
+          const starValue = Number(event.target.value);
+          onFocus(id, starValue);
+        }
+      },
+      [onFocus, id]
+    );
+    const handleBlur = react.useCallback(
+      (event) => {
+        if (onBlur) {
+          const starValue = Number(event.target.value);
+          onBlur(id, starValue);
+        }
+      },
+      [onBlur, id]
+    );
+    const getColorClass = (index) => {
+      if (!colorGradient) {
+        return `bg-${color}-400`;
+      }
+      const colors = ["red", "orange", "yellow", "lime", "green"];
+      const colorIdx = Math.min(index, colors.length - 1);
+      return `bg-${colors[colorIdx]}-400`;
+    };
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "form-control w-full", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: `rating gap-1 ${sizeClass}`, children: [...Array(numStars)].map((_, index) => {
+      const starValue = min + index;
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "radio",
+          name: id,
+          value: starValue,
+          checked: value === starValue,
+          onChange: _onChange,
+          onFocus: handleFocus,
+          onBlur: handleBlur,
+          className: `mask ${maskClass} ${getColorClass(index)}`,
+          disabled: disabled || readonly,
+          required,
+          autoFocus: autofocus && index === 0,
+          "aria-label": `${starValue} ${shape === "heart" ? "heart" : "star"}${starValue === 1 ? "" : "s"}`
+        },
+        index
+      );
+    }) }) });
+  }
+  function SelectWidget({
+    schema,
+    id,
+    options,
+    label,
+    disabled,
+    placeholder,
+    readonly,
+    value,
+    multiple,
+    onChange,
+    onBlur,
+    onFocus
+  }) {
+    const { enumOptions, emptyValue: optEmptyVal } = options;
+    multiple = typeof multiple === "undefined" ? false : !!multiple;
+    const getDisplayValue = (val) => {
+      if (!val) {
+        return "";
+      }
+      if (typeof val === "object") {
+        if (val.name) {
+          return val.name;
+        }
+        return val.label || JSON.stringify(val);
+      }
+      return String(val);
+    };
+    const isEnumeratedObject = enumOptions && enumOptions[0]?.value && typeof enumOptions[0].value === "object";
+    const handleOptionClick = react.useCallback(
+      (event) => {
+        const index = Number(event.currentTarget.dataset.value);
+        if (isNaN(index)) {
+          return;
+        }
+        if (multiple) {
+          const currentValue = Array.isArray(value) ? value : [];
+          const optionValue = isEnumeratedObject ? enumOptions[index].value : utils.enumOptionsValueForIndex(String(index), enumOptions, optEmptyVal);
+          const newValue = currentValue.includes(optionValue) ? currentValue.filter((v) => v !== optionValue) : [...currentValue, optionValue];
+          onChange(newValue);
+        } else {
+          onChange(
+            isEnumeratedObject ? enumOptions[index].value : utils.enumOptionsValueForIndex(String(index), enumOptions, optEmptyVal)
+          );
+        }
+      },
+      [value, multiple, isEnumeratedObject, enumOptions, optEmptyVal, onChange]
+    );
+    const _onBlur = react.useCallback(
+      ({ target }) => {
+        const dataValue = target?.getAttribute("data-value");
+        if (dataValue !== null) {
+          onBlur(id, utils.enumOptionsValueForIndex(dataValue, enumOptions, optEmptyVal));
+        }
+      },
+      [onBlur, id, enumOptions, optEmptyVal]
+    );
+    const _onFocus = react.useCallback(
+      ({ target }) => {
+        const dataValue = target?.getAttribute("data-value");
+        if (dataValue !== null) {
+          onFocus(id, utils.enumOptionsValueForIndex(dataValue, enumOptions, optEmptyVal));
+        }
+      },
+      [onFocus, id, enumOptions, optEmptyVal]
+    );
+    const selectedIndexes = utils.enumOptionsIndexForValue(value, enumOptions, multiple);
+    const selectedValues = Array.isArray(selectedIndexes) ? selectedIndexes : [selectedIndexes];
+    const optionsList = enumOptions || (Array.isArray(schema.examples) ? schema.examples.map((example) => ({ value: example, label: example })) : []);
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "form-control w-full", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "dropdown w-full", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          tabIndex: 0,
+          role: "button",
+          className: `btn btn-outline w-full text-left flex justify-between items-center ${disabled || readonly ? "btn-disabled" : ""}`,
+          onBlur: _onBlur,
+          onFocus: _onFocus,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: selectedValues.length > 0 ? selectedValues.map((index) => optionsList[Number(index)]?.label).join(", ") : placeholder || label || "Select..." }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ml-2", children: "\u25BC" })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "dropdown-content z-[1] bg-base-100 w-full max-h-60 overflow-auto rounded-box shadow-lg", children: optionsList.map(({ label: label2 }, i) => /* @__PURE__ */ jsxRuntime.jsx(
+        "li",
+        {
+          role: "button",
+          tabIndex: 0,
+          className: `px-4 py-2 hover:bg-base-200 cursor-pointer ${selectedValues.includes(String(i)) ? "bg-primary/10" : ""}`,
+          onClick: handleOptionClick,
+          "data-value": i,
+          children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+            multiple && /* @__PURE__ */ jsxRuntime.jsx(
+              "input",
+              {
+                type: "checkbox",
+                className: "checkbox checkbox-sm",
+                checked: selectedValues.includes(String(i)),
+                readOnly: true
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { children: isEnumeratedObject ? label2 : getDisplayValue(label2) })
+          ] })
+        },
+        i
+      )) })
+    ] }) });
+  }
+  function TextareaWidget(props) {
+    const { id, value, required, disabled, readonly, onChange, onFocus, onBlur, options } = props;
+    const handleFocus = react.useCallback(
+      (event) => {
+        if (onFocus) {
+          onFocus(id, event.target.value);
+        }
+      },
+      [onFocus, id]
+    );
+    const handleBlur = react.useCallback(
+      (event) => {
+        if (onBlur) {
+          onBlur(id, event.target.value);
+        }
+      },
+      [onBlur, id]
+    );
+    const handleChange = react.useCallback(
+      (event) => {
+        onChange(event.target.value);
+      },
+      [onChange]
+    );
+    const rows = options?.rows || 5;
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "form-control", children: /* @__PURE__ */ jsxRuntime.jsx(
+      "textarea",
+      {
+        id,
+        value: value || "",
+        required,
+        disabled: disabled || readonly,
+        readOnly: readonly,
+        rows,
+        onChange: handleChange,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        className: "textarea textarea-bordered w-full"
+      }
+    ) });
+  }
+  function TimeWidget(props) {
+    const { id, value, onChange, onFocus, onBlur, required, disabled, readonly } = props;
+    const handleFocus = react.useCallback(
+      (event) => {
+        if (onFocus) {
+          onFocus(id, event.target.value);
+        }
+      },
+      [onFocus, id]
+    );
+    const handleBlur = react.useCallback(
+      (event) => {
+        if (onBlur) {
+          onBlur(id, event.target.value);
+        }
+      },
+      [onBlur, id]
+    );
+    const handleChange = react.useCallback(
+      (event) => {
+        onChange(event.target.value);
+      },
+      [onChange]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "form-control", children: /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        type: "time",
+        id,
+        className: "input input-bordered w-full",
+        value: value || "",
+        required,
+        disabled: disabled || readonly,
+        readOnly: readonly,
+        onChange: handleChange,
+        onFocus: handleFocus,
+        onBlur: handleBlur
+      }
+    ) });
+  }
+  function ToggleWidget({ id, value, required, disabled, readonly, autofocus, onChange, onFocus, onBlur, options }) {
+    const _onChange = react.useCallback(
+      ({ target: { checked } }) => onChange(checked),
+      [onChange]
+    );
+    const handleFocus = react.useCallback(() => {
+      if (onFocus) {
+        onFocus(id, value);
+      }
+    }, [onFocus, id, value]);
+    const handleBlur = react.useCallback(() => {
+      if (onBlur) {
+        onBlur(id, value);
+      }
+    }, [onBlur, id, value]);
+    const { size = "md" } = options;
+    const sizeClass = size !== "md" ? `toggle-${size}` : "";
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "form-control", children: /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "cursor-pointer label my-auto", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "checkbox",
+          id,
+          checked: value,
+          required,
+          disabled: disabled || readonly,
+          autoFocus: autofocus,
+          onChange: _onChange,
+          onFocus: handleFocus,
+          onBlur: handleBlur,
+          className: `toggle ${sizeClass}`
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "label-text", children: options.label })
+    ] }) });
+  }
+
+  // src/widgets/Widgets.tsx
+  function generateWidgets() {
+    return {
+      AltDateTimeWidget: AltDateTimeWidget_default,
+      AltDateWidget,
+      CheckboxesWidget,
+      CheckboxWidget,
+      DateTimeWidget,
+      DateWidget,
+      FileWidget,
+      RadioWidget,
+      RangeWidget,
+      RatingWidget,
+      SelectWidget,
+      TextareaWidget,
+      TimeWidget,
+      toggle: ToggleWidget
+    };
+  }
+  var Widgets_default = generateWidgets;
+  function generateTheme() {
+    const { fields } = core.getDefaultRegistry();
+    const generatedWidgets = generateWidgets();
+    const templates = generateTemplates();
+    return {
+      templates,
+      widgets: {
+        ...generatedWidgets,
+        boolean: generatedWidgets.toggle
+      },
+      fields
+    };
+  }
+  var Theme = generateTheme();
+  var Theme_default = Theme;
+  var ThemeContext = react.createContext({
+    theme: "night",
+    setTheme: () => {
+    }
+  });
+  function ThemeProvider({ children }) {
+    const [theme, setTheme] = react.useState(() => {
+      try {
+        return localStorage.getItem("daisyui-theme") || "cupcake";
+      } catch {
+        return "cupcake";
+      }
+    });
+    const handleSetTheme = react.useCallback((newTheme) => {
+      try {
+        localStorage.setItem("daisyui-theme", newTheme);
+        setTheme(newTheme);
+      } catch {
+      }
+    }, []);
+    return /* @__PURE__ */ jsxRuntime.jsx(ThemeContext.Provider, { value: { theme, setTheme: handleSetTheme }, children });
+  }
+  var useTheme = () => react.useContext(ThemeContext);
+  var DaisyUIForm = core.withTheme(Theme_default);
+  var DaisyUIForm_default = DaisyUIForm;
+  function DaisyUIFrameComponent(props) {
+    const { children, subtheme = {}, document: document2 } = props;
+    const theme = (() => {
+      try {
+        if (subtheme?.dataTheme) {
+          localStorage.setItem("daisyui-theme", subtheme.dataTheme);
+          return subtheme.dataTheme;
+        }
+        return localStorage.getItem("daisyui-theme") || "cupcake";
+      } catch {
+        return "cupcake";
+      }
+    })();
+    react.useEffect(() => {
+      if (document2) {
+        const configScript = document2.createElement("script");
+        configScript.textContent = `
+        window.tailwind = window.tailwind || {};
+        window.tailwind.config = {
+          daisyui: {
+            themes: true,
+          },
+          future: {
+            disableProductionWarning: true
+          }
+        }
+      `;
+        document2.head.appendChild(configScript);
+        const tailwindScript = document2.createElement("script");
+        tailwindScript.src = "https://unpkg.com/@tailwindcss/browser@4.1.3";
+        document2.head.appendChild(tailwindScript);
+        const daisyLink = document2.createElement("link");
+        daisyLink.rel = "stylesheet";
+        daisyLink.href = "https://cdn.jsdelivr.net/npm/daisyui@5.0.20";
+        document2.head.appendChild(daisyLink);
+        const daisyLinkAllThemes = document2.createElement("link");
+        daisyLinkAllThemes.rel = "stylesheet";
+        daisyLinkAllThemes.href = "https://cdn.jsdelivr.net/npm/daisyui@5.0.20/themes.css";
+        document2.head.appendChild(daisyLinkAllThemes);
+        return () => {
+          configScript.remove();
+          tailwindScript.remove();
+          daisyLink.remove();
+          daisyLinkAllThemes.remove();
+        };
+      }
+      return void 0;
+    }, [document2]);
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { "data-theme": theme, className: "daisy-ui-theme", children });
+  }
+  var __createDaisyUIFrameProvider = (props) => {
+    return function DaisyUIFrame({ document: document2 }) {
+      return /* @__PURE__ */ jsxRuntime.jsx(DaisyUIFrameComponent, { document: document2, ...props });
+    };
+  };
+
+  // src/index.ts
+  var index_default = core.withTheme(Theme_default);
+
+  exports.Form = DaisyUIForm_default;
+  exports.GridTemplate = GridTemplate;
+  exports.Templates = Templates_default;
+  exports.Theme = Theme_default;
+  exports.ThemeProvider = ThemeProvider;
+  exports.Widgets = Widgets_default;
+  exports.__createDaisyUIFrameProvider = __createDaisyUIFrameProvider;
+  exports.default = index_default;
+  exports.useTheme = useTheme;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));