sanity-plugin-recurring-dates 1.4.1 → 2.0.0

package/dist/index.mjs

@@ -0,0 +1,2520 @@
+import { set, unset, ObjectInputMember, defineField, definePlugin } from "sanity";
+import { ChevronLeftIcon, ChevronRightIcon, CalendarIcon, WarningOutlineIcon, TrashIcon } from "@sanity/icons";
+import { jsx, jsxs, Fragment as Fragment$1 } from "react/jsx-runtime";
+import { Card, Text, Box, Grid, TextInput, useForwardedRef, Flex, Select, Button, useClickOutside, LayerProvider, Popover, Stack, Dialog, Radio } from "@sanity/ui";
+import upperFirst from "lodash/upperFirst.js";
+import * as React from "react";
+import React__default, { useState, createContext, forwardRef, useRef, useCallback, useEffect, useMemo, Fragment, PureComponent } from "react";
+import { rrulestr, Weekday, RRule, datetime } from "rrule";
+import { Feedback } from "sanity-plugin-utils";
+import { toDate as toDate$1, format as format$1 } from "date-fns-tz";
+import { format, parse, DEFAULT_DATE_FORMAT as DEFAULT_DATE_FORMAT$1, DEFAULT_TIME_FORMAT } from "@sanity/util/legacyDateFormat";
+import require$$0 from "react-is";
+import range from "lodash/range.js";
+const DEFAULT_RECURRENCES = [
+  "RRULE:FREQ=DAILY;INTERVAL=1",
+  "RRULE:FREQ=WEEKLY;INTERVAL=1",
+  "RRULE:FREQ=MONTHLY;INTERVAL=1",
+  "RRULE:FREQ=YEARLY;INTERVAL=1"
+], DEFAULT_CONFIG = {
+  defaultRecurrences: DEFAULT_RECURRENCES
+}, DAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"], DEFAULT_COUNTS = [
+  5,
+  // yearly
+  12,
+  // monthly
+  12,
+  // weekly
+  30
+  // daily
+], validateRRuleString = (recurrence) => {
+  try {
+    return rrulestr(recurrence), !1;
+  } catch {
+    return !0;
+  }
+}, validateRRuleStrings = (recurrences) => recurrences.some((recurrence) => validateRRuleString(recurrence));
+function _objectWithoutPropertiesLoose(r, e) {
+  if (r == null) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (e.indexOf(n) !== -1) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+var propTypes$1 = { exports: {} };
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var objectAssign, hasRequiredObjectAssign;
+function requireObjectAssign() {
+  if (hasRequiredObjectAssign) return objectAssign;
+  hasRequiredObjectAssign = 1;
+  var getOwnPropertySymbols = Object.getOwnPropertySymbols, hasOwnProperty = Object.prototype.hasOwnProperty, propIsEnumerable = Object.prototype.propertyIsEnumerable;
+  function toObject(val) {
+    if (val == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(val);
+  }
+  function shouldUseNative() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var test1 = new String("abc");
+      if (test1[5] = "de", Object.getOwnPropertyNames(test1)[0] === "5")
+        return !1;
+      for (var test2 = {}, i = 0; i < 10; i++)
+        test2["_" + String.fromCharCode(i)] = i;
+      var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
+        return test2[n];
+      });
+      if (order2.join("") !== "0123456789")
+        return !1;
+      var test3 = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+        test3[letter] = letter;
+      }), Object.keys(Object.assign({}, test3)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return objectAssign = shouldUseNative() ? Object.assign : function(target, source) {
+    for (var from, to = toObject(target), symbols, s = 1; s < arguments.length; s++) {
+      from = Object(arguments[s]);
+      for (var key in from)
+        hasOwnProperty.call(from, key) && (to[key] = from[key]);
+      if (getOwnPropertySymbols) {
+        symbols = getOwnPropertySymbols(from);
+        for (var i = 0; i < symbols.length; i++)
+          propIsEnumerable.call(from, symbols[i]) && (to[symbols[i]] = from[symbols[i]]);
+      }
+    }
+    return to;
+  }, objectAssign;
+}
+var ReactPropTypesSecret_1, hasRequiredReactPropTypesSecret;
+function requireReactPropTypesSecret() {
+  if (hasRequiredReactPropTypesSecret) return ReactPropTypesSecret_1;
+  hasRequiredReactPropTypesSecret = 1;
+  var ReactPropTypesSecret = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return ReactPropTypesSecret_1 = ReactPropTypesSecret, ReactPropTypesSecret_1;
+}
+var has, hasRequiredHas;
+function requireHas() {
+  return hasRequiredHas || (hasRequiredHas = 1, has = Function.call.bind(Object.prototype.hasOwnProperty)), has;
+}
+var checkPropTypes_1, hasRequiredCheckPropTypes;
+function requireCheckPropTypes() {
+  if (hasRequiredCheckPropTypes) return checkPropTypes_1;
+  hasRequiredCheckPropTypes = 1;
+  var printWarning = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var ReactPropTypesSecret = requireReactPropTypesSecret(), loggedTypeFailures = {}, has2 = requireHas();
+    printWarning = function(text) {
+      var message = "Warning: " + text;
+      typeof console < "u" && console.error(message);
+      try {
+        throw new Error(message);
+      } catch {
+      }
+    };
+  }
+  function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var typeSpecName in typeSpecs)
+        if (has2(typeSpecs, typeSpecName)) {
+          var error;
+          try {
+            if (typeof typeSpecs[typeSpecName] != "function") {
+              var err = Error(
+                (componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw err.name = "Invariant Violation", err;
+            }
+            error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+          } catch (ex) {
+            error = ex;
+          }
+          if (error && !(error instanceof Error) && printWarning(
+            (componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof error + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), error instanceof Error && !(error.message in loggedTypeFailures)) {
+            loggedTypeFailures[error.message] = !0;
+            var stack = getStack ? getStack() : "";
+            printWarning(
+              "Failed " + location + " type: " + error.message + (stack ?? "")
+            );
+          }
+        }
+    }
+  }
+  return checkPropTypes.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (loggedTypeFailures = {});
+  }, checkPropTypes_1 = checkPropTypes, checkPropTypes_1;
+}
+var factoryWithTypeCheckers, hasRequiredFactoryWithTypeCheckers;
+function requireFactoryWithTypeCheckers() {
+  if (hasRequiredFactoryWithTypeCheckers) return factoryWithTypeCheckers;
+  hasRequiredFactoryWithTypeCheckers = 1;
+  var ReactIs = require$$0, assign = requireObjectAssign(), ReactPropTypesSecret = requireReactPropTypesSecret(), has2 = requireHas(), checkPropTypes = requireCheckPropTypes(), printWarning = function() {
+  };
+  process.env.NODE_ENV !== "production" && (printWarning = function(text) {
+    var message = "Warning: " + text;
+    typeof console < "u" && console.error(message);
+    try {
+      throw new Error(message);
+    } catch {
+    }
+  });
+  function emptyFunctionThatReturnsNull() {
+    return null;
+  }
+  return factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
+    var ITERATOR_SYMBOL = typeof Symbol == "function" && Symbol.iterator, FAUX_ITERATOR_SYMBOL = "@@iterator";
+    function getIteratorFn(maybeIterable) {
+      var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+      if (typeof iteratorFn == "function")
+        return iteratorFn;
+    }
+    var ANONYMOUS = "<<anonymous>>", ReactPropTypes = {
+      array: createPrimitiveTypeChecker("array"),
+      bigint: createPrimitiveTypeChecker("bigint"),
+      bool: createPrimitiveTypeChecker("boolean"),
+      func: createPrimitiveTypeChecker("function"),
+      number: createPrimitiveTypeChecker("number"),
+      object: createPrimitiveTypeChecker("object"),
+      string: createPrimitiveTypeChecker("string"),
+      symbol: createPrimitiveTypeChecker("symbol"),
+      any: createAnyTypeChecker(),
+      arrayOf: createArrayOfTypeChecker,
+      element: createElementTypeChecker(),
+      elementType: createElementTypeTypeChecker(),
+      instanceOf: createInstanceTypeChecker,
+      node: createNodeChecker(),
+      objectOf: createObjectOfTypeChecker,
+      oneOf: createEnumTypeChecker,
+      oneOfType: createUnionTypeChecker,
+      shape: createShapeTypeChecker,
+      exact: createStrictShapeTypeChecker
+    };
+    function is(x, y) {
+      return x === y ? x !== 0 || 1 / x === 1 / y : x !== x && y !== y;
+    }
+    function PropTypeError(message, data) {
+      this.message = message, this.data = data && typeof data == "object" ? data : {}, this.stack = "";
+    }
+    PropTypeError.prototype = Error.prototype;
+    function createChainableTypeChecker(validate) {
+      if (process.env.NODE_ENV !== "production")
+        var manualPropTypeCallCache = {}, manualPropTypeWarningCount = 0;
+      function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+        if (componentName = componentName || ANONYMOUS, propFullName = propFullName || propName, secret !== ReactPropTypesSecret) {
+          if (throwOnDirectAccess) {
+            var err = new Error(
+              "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+            );
+            throw err.name = "Invariant Violation", err;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var cacheKey = componentName + ":" + propName;
+            !manualPropTypeCallCache[cacheKey] && // Avoid spamming the console because they are often not actionable except for lib authors
+            manualPropTypeWarningCount < 3 && (printWarning(
+              "You are manually calling a React.PropTypes validation function for the `" + propFullName + "` prop on `" + componentName + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+            ), manualPropTypeCallCache[cacheKey] = !0, manualPropTypeWarningCount++);
+          }
+        }
+        return props[propName] == null ? isRequired ? props[propName] === null ? new PropTypeError("The " + location + " `" + propFullName + "` is marked as required " + ("in `" + componentName + "`, but its value is `null`.")) : new PropTypeError("The " + location + " `" + propFullName + "` is marked as required in " + ("`" + componentName + "`, but its value is `undefined`.")) : null : validate(props, propName, componentName, location, propFullName);
+      }
+      var chainedCheckType = checkType.bind(null, !1);
+      return chainedCheckType.isRequired = checkType.bind(null, !0), chainedCheckType;
+    }
+    function createPrimitiveTypeChecker(expectedType) {
+      function validate(props, propName, componentName, location, propFullName, secret) {
+        var propValue = props[propName], propType = getPropType(propValue);
+        if (propType !== expectedType) {
+          var preciseType = getPreciseType(propValue);
+          return new PropTypeError(
+            "Invalid " + location + " `" + propFullName + "` of type " + ("`" + preciseType + "` supplied to `" + componentName + "`, expected ") + ("`" + expectedType + "`."),
+            { expectedType }
+          );
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createAnyTypeChecker() {
+      return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+    }
+    function createArrayOfTypeChecker(typeChecker) {
+      function validate(props, propName, componentName, location, propFullName) {
+        if (typeof typeChecker != "function")
+          return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside arrayOf.");
+        var propValue = props[propName];
+        if (!Array.isArray(propValue)) {
+          var propType = getPropType(propValue);
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an array."));
+        }
+        for (var i = 0; i < propValue.length; i++) {
+          var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret);
+          if (error instanceof Error)
+            return error;
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createElementTypeChecker() {
+      function validate(props, propName, componentName, location, propFullName) {
+        var propValue = props[propName];
+        if (!isValidElement(propValue)) {
+          var propType = getPropType(propValue);
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createElementTypeTypeChecker() {
+      function validate(props, propName, componentName, location, propFullName) {
+        var propValue = props[propName];
+        if (!ReactIs.isValidElementType(propValue)) {
+          var propType = getPropType(propValue);
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createInstanceTypeChecker(expectedClass) {
+      function validate(props, propName, componentName, location, propFullName) {
+        if (!(props[propName] instanceof expectedClass)) {
+          var expectedClassName = expectedClass.name || ANONYMOUS, actualClassName = getClassName(props[propName]);
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + actualClassName + "` supplied to `" + componentName + "`, expected ") + ("instance of `" + expectedClassName + "`."));
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createEnumTypeChecker(expectedValues) {
+      if (!Array.isArray(expectedValues))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? printWarning(
+          "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+        ) : printWarning("Invalid argument supplied to oneOf, expected an array.")), emptyFunctionThatReturnsNull;
+      function validate(props, propName, componentName, location, propFullName) {
+        for (var propValue = props[propName], i = 0; i < expectedValues.length; i++)
+          if (is(propValue, expectedValues[i]))
+            return null;
+        var valuesString = JSON.stringify(expectedValues, function(key, value) {
+          var type = getPreciseType(value);
+          return type === "symbol" ? String(value) : value;
+        });
+        return new PropTypeError("Invalid " + location + " `" + propFullName + "` of value `" + String(propValue) + "` " + ("supplied to `" + componentName + "`, expected one of " + valuesString + "."));
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createObjectOfTypeChecker(typeChecker) {
+      function validate(props, propName, componentName, location, propFullName) {
+        if (typeof typeChecker != "function")
+          return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside objectOf.");
+        var propValue = props[propName], propType = getPropType(propValue);
+        if (propType !== "object")
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an object."));
+        for (var key in propValue)
+          if (has2(propValue, key)) {
+            var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+            if (error instanceof Error)
+              return error;
+          }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createUnionTypeChecker(arrayOfTypeCheckers) {
+      if (!Array.isArray(arrayOfTypeCheckers))
+        return process.env.NODE_ENV !== "production" && printWarning("Invalid argument supplied to oneOfType, expected an instance of array."), emptyFunctionThatReturnsNull;
+      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+        var checker = arrayOfTypeCheckers[i];
+        if (typeof checker != "function")
+          return printWarning(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + getPostfixForTypeWarning(checker) + " at index " + i + "."
+          ), emptyFunctionThatReturnsNull;
+      }
+      function validate(props, propName, componentName, location, propFullName) {
+        for (var expectedTypes = [], i2 = 0; i2 < arrayOfTypeCheckers.length; i2++) {
+          var checker2 = arrayOfTypeCheckers[i2], checkerResult = checker2(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+          if (checkerResult == null)
+            return null;
+          checkerResult.data && has2(checkerResult.data, "expectedType") && expectedTypes.push(checkerResult.data.expectedType);
+        }
+        var expectedTypesMessage = expectedTypes.length > 0 ? ", expected one of type [" + expectedTypes.join(", ") + "]" : "";
+        return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`" + expectedTypesMessage + "."));
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createNodeChecker() {
+      function validate(props, propName, componentName, location, propFullName) {
+        return isNode(props[propName]) ? null : new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`, expected a ReactNode."));
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function invalidValidatorError(componentName, location, propFullName, key, type) {
+      return new PropTypeError(
+        (componentName || "React class") + ": " + location + " type `" + propFullName + "." + key + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + type + "`."
+      );
+    }
+    function createShapeTypeChecker(shapeTypes) {
+      function validate(props, propName, componentName, location, propFullName) {
+        var propValue = props[propName], propType = getPropType(propValue);
+        if (propType !== "object")
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+        for (var key in shapeTypes) {
+          var checker = shapeTypes[key];
+          if (typeof checker != "function")
+            return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+          var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+          if (error)
+            return error;
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createStrictShapeTypeChecker(shapeTypes) {
+      function validate(props, propName, componentName, location, propFullName) {
+        var propValue = props[propName], propType = getPropType(propValue);
+        if (propType !== "object")
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+        var allKeys = assign({}, props[propName], shapeTypes);
+        for (var key in allKeys) {
+          var checker = shapeTypes[key];
+          if (has2(shapeTypes, key) && typeof checker != "function")
+            return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+          if (!checker)
+            return new PropTypeError(
+              "Invalid " + location + " `" + propFullName + "` key `" + key + "` supplied to `" + componentName + "`.\nBad object: " + JSON.stringify(props[propName], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(shapeTypes), null, "  ")
+            );
+          var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+          if (error)
+            return error;
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function isNode(propValue) {
+      switch (typeof propValue) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !propValue;
+        case "object":
+          if (Array.isArray(propValue))
+            return propValue.every(isNode);
+          if (propValue === null || isValidElement(propValue))
+            return !0;
+          var iteratorFn = getIteratorFn(propValue);
+          if (iteratorFn) {
+            var iterator = iteratorFn.call(propValue), step;
+            if (iteratorFn !== propValue.entries) {
+              for (; !(step = iterator.next()).done; )
+                if (!isNode(step.value))
+                  return !1;
+            } else
+              for (; !(step = iterator.next()).done; ) {
+                var entry = step.value;
+                if (entry && !isNode(entry[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function isSymbol(propType, propValue) {
+      return propType === "symbol" ? !0 : propValue ? propValue["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && propValue instanceof Symbol : !1;
+    }
+    function getPropType(propValue) {
+      var propType = typeof propValue;
+      return Array.isArray(propValue) ? "array" : propValue instanceof RegExp ? "object" : isSymbol(propType, propValue) ? "symbol" : propType;
+    }
+    function getPreciseType(propValue) {
+      if (typeof propValue > "u" || propValue === null)
+        return "" + propValue;
+      var propType = getPropType(propValue);
+      if (propType === "object") {
+        if (propValue instanceof Date)
+          return "date";
+        if (propValue instanceof RegExp)
+          return "regexp";
+      }
+      return propType;
+    }
+    function getPostfixForTypeWarning(value) {
+      var type = getPreciseType(value);
+      switch (type) {
+        case "array":
+        case "object":
+          return "an " + type;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + type;
+        default:
+          return type;
+      }
+    }
+    function getClassName(propValue) {
+      return !propValue.constructor || !propValue.constructor.name ? ANONYMOUS : propValue.constructor.name;
+    }
+    return ReactPropTypes.checkPropTypes = checkPropTypes, ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache, ReactPropTypes.PropTypes = ReactPropTypes, ReactPropTypes;
+  }, factoryWithTypeCheckers;
+}
+var factoryWithThrowingShims, hasRequiredFactoryWithThrowingShims;
+function requireFactoryWithThrowingShims() {
+  if (hasRequiredFactoryWithThrowingShims) return factoryWithThrowingShims;
+  hasRequiredFactoryWithThrowingShims = 1;
+  var ReactPropTypesSecret = requireReactPropTypesSecret();
+  function emptyFunction() {
+  }
+  function emptyFunctionWithReset() {
+  }
+  return emptyFunctionWithReset.resetWarningCache = emptyFunction, factoryWithThrowingShims = function() {
+    function shim(props, propName, componentName, location, propFullName, secret) {
+      if (secret !== ReactPropTypesSecret) {
+        var err = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw err.name = "Invariant Violation", err;
+      }
+    }
+    shim.isRequired = shim;
+    function getShim() {
+      return shim;
+    }
+    var ReactPropTypes = {
+      array: shim,
+      bigint: shim,
+      bool: shim,
+      func: shim,
+      number: shim,
+      object: shim,
+      string: shim,
+      symbol: shim,
+      any: shim,
+      arrayOf: getShim,
+      element: shim,
+      elementType: shim,
+      instanceOf: getShim,
+      node: shim,
+      objectOf: getShim,
+      oneOf: getShim,
+      oneOfType: getShim,
+      shape: getShim,
+      exact: getShim,
+      checkPropTypes: emptyFunctionWithReset,
+      resetWarningCache: emptyFunction
+    };
+    return ReactPropTypes.PropTypes = ReactPropTypes, ReactPropTypes;
+  }, factoryWithThrowingShims;
+}
+var hasRequiredPropTypes;
+function requirePropTypes() {
+  if (hasRequiredPropTypes) return propTypes$1.exports;
+  if (hasRequiredPropTypes = 1, process.env.NODE_ENV !== "production") {
+    var ReactIs = require$$0, throwOnDirectAccess = !0;
+    propTypes$1.exports = requireFactoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
+  } else
+    propTypes$1.exports = requireFactoryWithThrowingShims()();
+  return propTypes$1.exports;
+}
+var propTypesExports = /* @__PURE__ */ requirePropTypes(), FOCUS_GROUP = "data-focus-lock", FOCUS_DISABLED = "data-focus-lock-disabled", FOCUS_ALLOW = "data-no-focus-lock", FOCUS_AUTO = "data-autofocus-inside", FOCUS_NO_AUTOFOCUS = "data-no-autofocus";
+function assignRef(ref, value) {
+  return typeof ref == "function" ? ref(value) : ref && (ref.current = value), ref;
+}
+function useCallbackRef(initialValue, callback) {
+  var ref = useState(function() {
+    return {
+      // value
+      value: initialValue,
+      // last callback
+      callback,
+      // "memoized" public interface
+      facade: {
+        get current() {
+          return ref.value;
+        },
+        set current(value) {
+          var last = ref.value;
+          last !== value && (ref.value = value, ref.callback(value, last));
+        }
+      }
+    };
+  })[0];
+  return ref.callback = callback, ref.facade;
+}
+var useIsomorphicLayoutEffect = typeof window < "u" ? React.useLayoutEffect : React.useEffect, currentValues = /* @__PURE__ */ new WeakMap();
+function useMergeRefs(refs, defaultValue) {
+  var callbackRef = useCallbackRef(null, function(newValue) {
+    return refs.forEach(function(ref) {
+      return assignRef(ref, newValue);
+    });
+  });
+  return useIsomorphicLayoutEffect(function() {
+    var oldValue = currentValues.get(callbackRef);
+    if (oldValue) {
+      var prevRefs_1 = new Set(oldValue), nextRefs_1 = new Set(refs), current_1 = callbackRef.current;
+      prevRefs_1.forEach(function(ref) {
+        nextRefs_1.has(ref) || assignRef(ref, null);
+      }), nextRefs_1.forEach(function(ref) {
+        prevRefs_1.has(ref) || assignRef(ref, current_1);
+      });
+    }
+    currentValues.set(callbackRef, refs);
+  }, [refs]), callbackRef;
+}
+var hiddenGuard = {
+  width: "1px",
+  height: "0px",
+  padding: 0,
+  overflow: "hidden",
+  position: "fixed",
+  top: "1px",
+  left: "1px"
+}, __assign = function() {
+  return __assign = Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) Object.prototype.hasOwnProperty.call(s, p) && (t[p] = s[p]);
+    }
+    return t;
+  }, __assign.apply(this, arguments);
+};
+function ItoI(a) {
+  return a;
+}
+function innerCreateMedium(defaults, middleware) {
+  middleware === void 0 && (middleware = ItoI);
+  var buffer = [], assigned = !1, medium = {
+    read: function() {
+      if (assigned)
+        throw new Error("Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.");
+      return buffer.length ? buffer[buffer.length - 1] : defaults;
+    },
+    useMedium: function(data) {
+      var item = middleware(data, assigned);
+      return buffer.push(item), function() {
+        buffer = buffer.filter(function(x) {
+          return x !== item;
+        });
+      };
+    },
+    assignSyncMedium: function(cb) {
+      for (assigned = !0; buffer.length; ) {
+        var cbs = buffer;
+        buffer = [], cbs.forEach(cb);
+      }
+      buffer = {
+        push: function(x) {
+          return cb(x);
+        },
+        filter: function() {
+          return buffer;
+        }
+      };
+    },
+    assignMedium: function(cb) {
+      assigned = !0;
+      var pendingQueue = [];
+      if (buffer.length) {
+        var cbs = buffer;
+        buffer = [], cbs.forEach(cb), pendingQueue = buffer;
+      }
+      var executeQueue = function() {
+        var cbs2 = pendingQueue;
+        pendingQueue = [], cbs2.forEach(cb);
+      }, cycle = function() {
+        return Promise.resolve().then(executeQueue);
+      };
+      cycle(), buffer = {
+        push: function(x) {
+          pendingQueue.push(x), cycle();
+        },
+        filter: function(filter) {
+          return pendingQueue = pendingQueue.filter(filter), buffer;
+        }
+      };
+    }
+  };
+  return medium;
+}
+function createMedium(defaults, middleware) {
+  return middleware === void 0 && (middleware = ItoI), innerCreateMedium(defaults, middleware);
+}
+function createSidecarMedium(options) {
+  options === void 0 && (options = {});
+  var medium = innerCreateMedium(null);
+  return medium.options = __assign({ async: !0, ssr: !1 }, options), medium;
+}
+var mediumFocus = createMedium({}, function(_ref2) {
+  var target = _ref2.target, currentTarget = _ref2.currentTarget;
+  return {
+    target,
+    currentTarget
+  };
+}), mediumBlur = createMedium(), mediumEffect = createMedium(), mediumSidecar = createSidecarMedium({
+  async: !0,
+  ssr: typeof document < "u"
+}), focusScope = /* @__PURE__ */ createContext(void 0), emptyArray = [], FocusLock = /* @__PURE__ */ forwardRef(function(props, parentRef) {
+  var _extends2, _useState = useState(), realObserved = _useState[0], setObserved = _useState[1], observed = useRef(), isActive = useRef(!1), originalFocusedElement = useRef(null), _useState2 = useState({}), update = _useState2[1], children = props.children, _props$disabled = props.disabled, disabled = _props$disabled === void 0 ? !1 : _props$disabled, _props$noFocusGuards = props.noFocusGuards, noFocusGuards = _props$noFocusGuards === void 0 ? !1 : _props$noFocusGuards, _props$persistentFocu = props.persistentFocus, persistentFocus = _props$persistentFocu === void 0 ? !1 : _props$persistentFocu, _props$crossFrame = props.crossFrame, crossFrame = _props$crossFrame === void 0 ? !0 : _props$crossFrame, _props$autoFocus = props.autoFocus, autoFocus = _props$autoFocus === void 0 ? !0 : _props$autoFocus, allowTextSelection = props.allowTextSelection, group = props.group, className = props.className, whiteList = props.whiteList, hasPositiveIndices = props.hasPositiveIndices, _props$shards = props.shards, shards = _props$shards === void 0 ? emptyArray : _props$shards, _props$as = props.as, Container = _props$as === void 0 ? "div" : _props$as, _props$lockProps = props.lockProps, containerProps = _props$lockProps === void 0 ? {} : _props$lockProps, SideCar = props.sideCar, _props$returnFocus = props.returnFocus, shouldReturnFocus = _props$returnFocus === void 0 ? !1 : _props$returnFocus, focusOptions = props.focusOptions, onActivationCallback = props.onActivation, onDeactivationCallback = props.onDeactivation, _useState3 = useState({}), id = _useState3[0], onActivation = useCallback(function(_ref2) {
+    var captureFocusRestore2 = _ref2.captureFocusRestore;
+    if (!originalFocusedElement.current) {
+      var _document, activeElement = (_document = document) == null ? void 0 : _document.activeElement;
+      originalFocusedElement.current = activeElement, activeElement !== document.body && (originalFocusedElement.current = captureFocusRestore2(activeElement));
+    }
+    observed.current && onActivationCallback && onActivationCallback(observed.current), isActive.current = !0, update();
+  }, [onActivationCallback]), onDeactivation = useCallback(function() {
+    isActive.current = !1, onDeactivationCallback && onDeactivationCallback(observed.current), update();
+  }, [onDeactivationCallback]), returnFocus = useCallback(function(allowDefer) {
+    var focusRestore = originalFocusedElement.current;
+    if (focusRestore) {
+      var returnFocusTo = (typeof focusRestore == "function" ? focusRestore() : focusRestore) || document.body, howToReturnFocus = typeof shouldReturnFocus == "function" ? shouldReturnFocus(returnFocusTo) : shouldReturnFocus;
+      if (howToReturnFocus) {
+        var returnFocusOptions = typeof howToReturnFocus == "object" ? howToReturnFocus : void 0;
+        originalFocusedElement.current = null, allowDefer ? Promise.resolve().then(function() {
+          return returnFocusTo.focus(returnFocusOptions);
+        }) : returnFocusTo.focus(returnFocusOptions);
+      }
+    }
+  }, [shouldReturnFocus]), onFocus3 = useCallback(function(event) {
+    isActive.current && mediumFocus.useMedium(event);
+  }, []), onBlur3 = mediumBlur.useMedium, setObserveNode = useCallback(function(newObserved) {
+    observed.current !== newObserved && (observed.current = newObserved, setObserved(newObserved));
+  }, []);
+  process.env.NODE_ENV !== "production" && (typeof allowTextSelection < "u" && console.warn("React-Focus-Lock: allowTextSelection is deprecated and enabled by default"), useEffect(function() {
+    !observed.current && typeof Container != "string" && console.error("FocusLock: could not obtain ref to internal node");
+  }, []));
+  var lockProps = _extends((_extends2 = {}, _extends2[FOCUS_DISABLED] = disabled && "disabled", _extends2[FOCUS_GROUP] = group, _extends2), containerProps), hasLeadingGuards = noFocusGuards !== !0, hasTailingGuards = hasLeadingGuards && noFocusGuards !== "tail", mergedRef = useMergeRefs([parentRef, setObserveNode]), focusScopeValue = useMemo(function() {
+    return {
+      observed,
+      shards,
+      enabled: !disabled,
+      active: isActive.current
+    };
+  }, [disabled, isActive.current, shards, realObserved]);
+  return /* @__PURE__ */ React__default.createElement(Fragment, null, hasLeadingGuards && [
+    /* @__PURE__ */ React__default.createElement("div", {
+      key: "guard-first",
+      "data-focus-guard": !0,
+      tabIndex: disabled ? -1 : 0,
+      style: hiddenGuard
+    }),
+    hasPositiveIndices ? /* @__PURE__ */ React__default.createElement("div", {
+      key: "guard-nearest",
+      "data-focus-guard": !0,
+      tabIndex: disabled ? -1 : 1,
+      style: hiddenGuard
+    }) : null
+  ], !disabled && /* @__PURE__ */ React__default.createElement(SideCar, {
+    id,
+    sideCar: mediumSidecar,
+    observed: realObserved,
+    disabled,
+    persistentFocus,
+    crossFrame,
+    autoFocus,
+    whiteList,
+    shards,
+    onActivation,
+    onDeactivation,
+    returnFocus,
+    focusOptions,
+    noFocusGuards
+  }), /* @__PURE__ */ React__default.createElement(Container, _extends({
+    ref: mergedRef
+  }, lockProps, {
+    className,
+    onBlur: onBlur3,
+    onFocus: onFocus3
+  }), /* @__PURE__ */ React__default.createElement(focusScope.Provider, {
+    value: focusScopeValue
+  }, children)), hasTailingGuards && /* @__PURE__ */ React__default.createElement("div", {
+    "data-focus-guard": !0,
+    tabIndex: disabled ? -1 : 0,
+    style: hiddenGuard
+  }));
+});
+FocusLock.propTypes = process.env.NODE_ENV !== "production" ? {
+  children: propTypesExports.node,
+  disabled: propTypesExports.bool,
+  returnFocus: propTypesExports.oneOfType([propTypesExports.bool, propTypesExports.object, propTypesExports.func]),
+  focusOptions: propTypesExports.object,
+  noFocusGuards: propTypesExports.bool,
+  hasPositiveIndices: propTypesExports.bool,
+  allowTextSelection: propTypesExports.bool,
+  autoFocus: propTypesExports.bool,
+  persistentFocus: propTypesExports.bool,
+  crossFrame: propTypesExports.bool,
+  group: propTypesExports.string,
+  className: propTypesExports.string,
+  whiteList: propTypesExports.func,
+  shards: propTypesExports.arrayOf(propTypesExports.any),
+  as: propTypesExports.oneOfType([propTypesExports.string, propTypesExports.func, propTypesExports.object]),
+  lockProps: propTypesExports.object,
+  onActivation: propTypesExports.func,
+  onDeactivation: propTypesExports.func,
+  sideCar: propTypesExports.any.isRequired
+} : {};
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
+    return t2.__proto__ = e2, t2;
+  }, _setPrototypeOf(t, e);
+}
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+function _typeof(o) {
+  "@babel/helpers - typeof";
+  return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && typeof Symbol == "function" && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
+}
+function toPrimitive(t, r) {
+  if (_typeof(t) != "object" || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var i = e.call(t, r);
+    if (_typeof(i) != "object") return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (r === "string" ? String : Number)(t);
+}
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return _typeof(i) == "symbol" ? i : i + "";
+}
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+function withSideEffect(reducePropsToState2, handleStateChangeOnClient2) {
+  if (process.env.NODE_ENV !== "production") {
+    if (typeof reducePropsToState2 != "function")
+      throw new Error("Expected reducePropsToState to be a function.");
+    if (typeof handleStateChangeOnClient2 != "function")
+      throw new Error("Expected handleStateChangeOnClient to be a function.");
+  }
+  function getDisplayName(WrappedComponent) {
+    return WrappedComponent.displayName || WrappedComponent.name || "Component";
+  }
+  return function(WrappedComponent) {
+    if (process.env.NODE_ENV !== "production" && typeof WrappedComponent != "function")
+      throw new Error("Expected WrappedComponent to be a React component.");
+    var mountedInstances = [], state;
+    function emitChange() {
+      state = reducePropsToState2(mountedInstances.map(function(instance) {
+        return instance.props;
+      })), handleStateChangeOnClient2(state);
+    }
+    var SideEffect = /* @__PURE__ */ function(_PureComponent) {
+      _inheritsLoose(SideEffect2, _PureComponent);
+      function SideEffect2() {
+        return _PureComponent.apply(this, arguments) || this;
+      }
+      SideEffect2.peek = function() {
+        return state;
+      };
+      var _proto = SideEffect2.prototype;
+      return _proto.componentDidMount = function() {
+        mountedInstances.push(this), emitChange();
+      }, _proto.componentDidUpdate = function() {
+        emitChange();
+      }, _proto.componentWillUnmount = function() {
+        var index = mountedInstances.indexOf(this);
+        mountedInstances.splice(index, 1), emitChange();
+      }, _proto.render = function() {
+        return /* @__PURE__ */ React__default.createElement(WrappedComponent, this.props);
+      }, SideEffect2;
+    }(PureComponent);
+    return _defineProperty(SideEffect, "displayName", "SideEffect(" + getDisplayName(WrappedComponent) + ")"), SideEffect;
+  };
+}
+var toArray = function(a) {
+  for (var ret = Array(a.length), i = 0; i < a.length; ++i)
+    ret[i] = a[i];
+  return ret;
+}, asArray = function(a) {
+  return Array.isArray(a) ? a : [a];
+}, getFirst = function(a) {
+  return Array.isArray(a) ? a[0] : a;
+}, isElementHidden = function(node) {
+  if (node.nodeType !== Node.ELEMENT_NODE)
+    return !1;
+  var computedStyle = window.getComputedStyle(node, null);
+  return !computedStyle || !computedStyle.getPropertyValue ? !1 : computedStyle.getPropertyValue("display") === "none" || computedStyle.getPropertyValue("visibility") === "hidden";
+}, getParentNode = function(node) {
+  return node.parentNode && node.parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    node.parentNode.host
+  ) : node.parentNode;
+}, isTopNode = function(node) {
+  return node === document || node && node.nodeType === Node.DOCUMENT_NODE;
+}, isInert = function(node) {
+  return node.hasAttribute("inert");
+}, isVisibleUncached = function(node, checkParent) {
+  return !node || isTopNode(node) || !isElementHidden(node) && !isInert(node) && checkParent(getParentNode(node));
+}, isVisibleCached = function(visibilityCache, node) {
+  var cached = visibilityCache.get(node);
+  if (cached !== void 0)
+    return cached;
+  var result = isVisibleUncached(node, isVisibleCached.bind(void 0, visibilityCache));
+  return visibilityCache.set(node, result), result;
+}, isAutoFocusAllowedUncached = function(node, checkParent) {
+  return node && !isTopNode(node) ? isAutoFocusAllowed(node) ? checkParent(getParentNode(node)) : !1 : !0;
+}, isAutoFocusAllowedCached = function(cache, node) {
+  var cached = cache.get(node);
+  if (cached !== void 0)
+    return cached;
+  var result = isAutoFocusAllowedUncached(node, isAutoFocusAllowedCached.bind(void 0, cache));
+  return cache.set(node, result), result;
+}, getDataset = function(node) {
+  return node.dataset;
+}, isHTMLButtonElement = function(node) {
+  return node.tagName === "BUTTON";
+}, isHTMLInputElement = function(node) {
+  return node.tagName === "INPUT";
+}, isRadioElement = function(node) {
+  return isHTMLInputElement(node) && node.type === "radio";
+}, notHiddenInput = function(node) {
+  return !((isHTMLInputElement(node) || isHTMLButtonElement(node)) && (node.type === "hidden" || node.disabled));
+}, isAutoFocusAllowed = function(node) {
+  var attribute = node.getAttribute(FOCUS_NO_AUTOFOCUS);
+  return ![!0, "true", ""].includes(attribute);
+}, isGuard = function(node) {
+  var _a;
+  return !!(node && (!((_a = getDataset(node)) === null || _a === void 0) && _a.focusGuard));
+}, isNotAGuard = function(node) {
+  return !isGuard(node);
+}, isDefined = function(x) {
+  return !!x;
+}, tabSort = function(a, b) {
+  var aTab = Math.max(0, a.tabIndex), bTab = Math.max(0, b.tabIndex), tabDiff = aTab - bTab, indexDiff = a.index - b.index;
+  if (tabDiff) {
+    if (!aTab)
+      return 1;
+    if (!bTab)
+      return -1;
+  }
+  return tabDiff || indexDiff;
+}, getTabIndex = function(node) {
+  return node.tabIndex < 0 && !node.hasAttribute("tabindex") ? 0 : node.tabIndex;
+}, orderByTabIndex = function(nodes, filterNegative, keepGuards) {
+  return toArray(nodes).map(function(node, index) {
+    var tabIndex = getTabIndex(node);
+    return {
+      node,
+      index,
+      tabIndex: keepGuards && tabIndex === -1 ? (node.dataset || {}).focusGuard ? 0 : -1 : tabIndex
+    };
+  }).filter(function(data) {
+    return !filterNegative || data.tabIndex >= 0;
+  }).sort(tabSort);
+}, tabbables = [
+  "button:enabled",
+  "select:enabled",
+  "textarea:enabled",
+  "input:enabled",
+  // elements with explicit roles will also use explicit tabindex
+  // '[role="button"]',
+  "a[href]",
+  "area[href]",
+  "summary",
+  "iframe",
+  "object",
+  "embed",
+  "audio[controls]",
+  "video[controls]",
+  "[tabindex]",
+  "[contenteditable]",
+  "[autofocus]"
+], queryTabbables = tabbables.join(","), queryGuardTabbables = "".concat(queryTabbables, ", [data-focus-guard]"), getFocusablesWithShadowDom = function(parent, withGuards) {
+  return toArray((parent.shadowRoot || parent).children).reduce(function(acc, child) {
+    return acc.concat(child.matches(withGuards ? queryGuardTabbables : queryTabbables) ? [child] : [], getFocusablesWithShadowDom(child));
+  }, []);
+}, getFocusablesWithIFrame = function(parent, withGuards) {
+  var _a;
+  return parent instanceof HTMLIFrameElement && (!((_a = parent.contentDocument) === null || _a === void 0) && _a.body) ? getFocusables([parent.contentDocument.body], withGuards) : [parent];
+}, getFocusables = function(parents, withGuards) {
+  return parents.reduce(function(acc, parent) {
+    var _a, focusableWithShadowDom = getFocusablesWithShadowDom(parent, withGuards), focusableWithIframes = (_a = []).concat.apply(_a, focusableWithShadowDom.map(function(node) {
+      return getFocusablesWithIFrame(node, withGuards);
+    }));
+    return acc.concat(
+      // add all tabbables inside and within shadow DOMs in DOM order
+      focusableWithIframes,
+      // add if node is tabbable itself
+      parent.parentNode ? toArray(parent.parentNode.querySelectorAll(queryTabbables)).filter(function(node) {
+        return node === parent;
+      }) : []
+    );
+  }, []);
+}, getParentAutofocusables = function(parent) {
+  var parentFocus = parent.querySelectorAll("[".concat(FOCUS_AUTO, "]"));
+  return toArray(parentFocus).map(function(node) {
+    return getFocusables([node]);
+  }).reduce(function(acc, nodes) {
+    return acc.concat(nodes);
+  }, []);
+}, filterFocusable = function(nodes, visibilityCache) {
+  return toArray(nodes).filter(function(node) {
+    return isVisibleCached(visibilityCache, node);
+  }).filter(function(node) {
+    return notHiddenInput(node);
+  });
+}, filterAutoFocusable = function(nodes, cache) {
+  return cache === void 0 && (cache = /* @__PURE__ */ new Map()), toArray(nodes).filter(function(node) {
+    return isAutoFocusAllowedCached(cache, node);
+  });
+}, getTabbableNodes = function(topNodes, visibilityCache, withGuards) {
+  return orderByTabIndex(filterFocusable(getFocusables(topNodes, withGuards), visibilityCache), !0, withGuards);
+}, getFocusableNodes = function(topNodes, visibilityCache) {
+  return orderByTabIndex(filterFocusable(getFocusables(topNodes), visibilityCache), !1);
+}, parentAutofocusables = function(topNode, visibilityCache) {
+  return filterFocusable(getParentAutofocusables(topNode), visibilityCache);
+}, contains = function(scope, element) {
+  return scope.shadowRoot ? contains(scope.shadowRoot, element) : Object.getPrototypeOf(scope).contains !== void 0 && Object.getPrototypeOf(scope).contains.call(scope, element) ? !0 : toArray(scope.children).some(function(child) {
+    var _a;
+    if (child instanceof HTMLIFrameElement) {
+      var iframeBody = (_a = child.contentDocument) === null || _a === void 0 ? void 0 : _a.body;
+      return iframeBody ? contains(iframeBody, element) : !1;
+    }
+    return contains(child, element);
+  });
+}, filterNested = function(nodes) {
+  for (var contained = /* @__PURE__ */ new Set(), l = nodes.length, i = 0; i < l; i += 1)
+    for (var j = i + 1; j < l; j += 1) {
+      var position = nodes[i].compareDocumentPosition(nodes[j]);
+      (position & Node.DOCUMENT_POSITION_CONTAINED_BY) > 0 && contained.add(j), (position & Node.DOCUMENT_POSITION_CONTAINS) > 0 && contained.add(i);
+    }
+  return nodes.filter(function(_, index) {
+    return !contained.has(index);
+  });
+}, getTopParent = function(node) {
+  return node.parentNode ? getTopParent(node.parentNode) : node;
+}, getAllAffectedNodes = function(node) {
+  var nodes = asArray(node);
+  return nodes.filter(Boolean).reduce(function(acc, currentNode) {
+    var group = currentNode.getAttribute(FOCUS_GROUP);
+    return acc.push.apply(acc, group ? filterNested(toArray(getTopParent(currentNode).querySelectorAll("[".concat(FOCUS_GROUP, '="').concat(group, '"]:not([').concat(FOCUS_DISABLED, '="disabled"])')))) : [currentNode]), acc;
+  }, []);
+}, safeProbe = function(cb) {
+  try {
+    return cb();
+  } catch {
+    return;
+  }
+}, getActiveElement = function(inDocument) {
+  if (inDocument === void 0 && (inDocument = document), !(!inDocument || !inDocument.activeElement)) {
+    var activeElement = inDocument.activeElement;
+    return activeElement.shadowRoot ? getActiveElement(activeElement.shadowRoot) : activeElement instanceof HTMLIFrameElement && safeProbe(function() {
+      return activeElement.contentWindow.document;
+    }) ? getActiveElement(activeElement.contentWindow.document) : activeElement;
+  }
+}, focusInFrame = function(frame, activeElement) {
+  return frame === activeElement;
+}, focusInsideIframe = function(topNode, activeElement) {
+  return !!toArray(topNode.querySelectorAll("iframe")).some(function(node) {
+    return focusInFrame(node, activeElement);
+  });
+}, focusInside = function(topNode, activeElement) {
+  return activeElement === void 0 && (activeElement = getActiveElement(getFirst(topNode).ownerDocument)), !activeElement || activeElement.dataset && activeElement.dataset.focusGuard ? !1 : getAllAffectedNodes(topNode).some(function(node) {
+    return contains(node, activeElement) || focusInsideIframe(node, activeElement);
+  });
+}, focusIsHidden = function(inDocument) {
+  inDocument === void 0 && (inDocument = document);
+  var activeElement = getActiveElement(inDocument);
+  return activeElement ? toArray(inDocument.querySelectorAll("[".concat(FOCUS_ALLOW, "]"))).some(function(node) {
+    return contains(node, activeElement);
+  }) : !1;
+}, findSelectedRadio = function(node, nodes) {
+  return nodes.filter(isRadioElement).filter(function(el) {
+    return el.name === node.name;
+  }).filter(function(el) {
+    return el.checked;
+  })[0] || node;
+}, correctNode = function(node, nodes) {
+  return isRadioElement(node) && node.name ? findSelectedRadio(node, nodes) : node;
+}, correctNodes = function(nodes) {
+  var resultSet = /* @__PURE__ */ new Set();
+  return nodes.forEach(function(node) {
+    return resultSet.add(correctNode(node, nodes));
+  }), nodes.filter(function(node) {
+    return resultSet.has(node);
+  });
+}, pickFirstFocus = function(nodes) {
+  return nodes[0] && nodes.length > 1 ? correctNode(nodes[0], nodes) : nodes[0];
+}, pickFocusable = function(nodes, node) {
+  return nodes.indexOf(correctNode(node, nodes));
+}, NEW_FOCUS = "NEW_FOCUS", newFocus = function(innerNodes, innerTabbables, outerNodes, activeElement, lastNode) {
+  var cnt = innerNodes.length, firstFocus = innerNodes[0], lastFocus = innerNodes[cnt - 1], isOnGuard = isGuard(activeElement);
+  if (!(activeElement && innerNodes.indexOf(activeElement) >= 0)) {
+    var activeIndex = activeElement !== void 0 ? outerNodes.indexOf(activeElement) : -1, lastIndex = lastNode ? outerNodes.indexOf(lastNode) : activeIndex, lastNodeInside = lastNode ? innerNodes.indexOf(lastNode) : -1;
+    if (activeIndex === -1)
+      return lastNodeInside !== -1 ? lastNodeInside : NEW_FOCUS;
+    if (lastNodeInside === -1)
+      return NEW_FOCUS;
+    var indexDiff = activeIndex - lastIndex, firstNodeIndex = outerNodes.indexOf(firstFocus), lastNodeIndex = outerNodes.indexOf(lastFocus), correctedNodes = correctNodes(outerNodes), currentFocusableIndex = activeElement !== void 0 ? correctedNodes.indexOf(activeElement) : -1, previousFocusableIndex = lastNode ? correctedNodes.indexOf(lastNode) : currentFocusableIndex, tabbableNodes = correctedNodes.filter(function(node) {
+      return node.tabIndex >= 0;
+    }), currentTabbableIndex = activeElement !== void 0 ? tabbableNodes.indexOf(activeElement) : -1, previousTabbableIndex = lastNode ? tabbableNodes.indexOf(lastNode) : currentTabbableIndex, focusIndexDiff = currentTabbableIndex >= 0 && previousTabbableIndex >= 0 ? (
+      // old/new are tabbables, measure distance in tabbable space
+      previousTabbableIndex - currentTabbableIndex
+    ) : (
+      // or else measure in focusable space
+      previousFocusableIndex - currentFocusableIndex
+    );
+    if (!indexDiff && lastNodeInside >= 0 || innerTabbables.length === 0)
+      return lastNodeInside;
+    var returnFirstNode = pickFocusable(innerNodes, innerTabbables[0]), returnLastNode = pickFocusable(innerNodes, innerTabbables[innerTabbables.length - 1]);
+    if (activeIndex <= firstNodeIndex && isOnGuard && Math.abs(indexDiff) > 1)
+      return returnLastNode;
+    if (activeIndex >= lastNodeIndex && isOnGuard && Math.abs(indexDiff) > 1)
+      return returnFirstNode;
+    if (indexDiff && Math.abs(focusIndexDiff) > 1)
+      return lastNodeInside;
+    if (activeIndex <= firstNodeIndex)
+      return returnLastNode;
+    if (activeIndex > lastNodeIndex)
+      return returnFirstNode;
+    if (indexDiff)
+      return Math.abs(indexDiff) > 1 ? lastNodeInside : (cnt + lastNodeInside + indexDiff) % cnt;
+  }
+}, findAutoFocused = function(autoFocusables) {
+  return function(node) {
+    var _a, autofocus = (_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.autofocus;
+    return (
+      // @ts-expect-error
+      node.autofocus || //
+      autofocus !== void 0 && autofocus !== "false" || //
+      autoFocusables.indexOf(node) >= 0
+    );
+  };
+}, pickAutofocus = function(nodesIndexes, orderedNodes, groups) {
+  var nodes = nodesIndexes.map(function(_a) {
+    var node = _a.node;
+    return node;
+  }), autoFocusable = filterAutoFocusable(nodes.filter(findAutoFocused(groups)));
+  return autoFocusable && autoFocusable.length ? pickFirstFocus(autoFocusable) : pickFirstFocus(filterAutoFocusable(orderedNodes));
+}, getParents = function(node, parents) {
+  return parents === void 0 && (parents = []), parents.push(node), node.parentNode && getParents(node.parentNode.host || node.parentNode, parents), parents;
+}, getCommonParent = function(nodeA, nodeB) {
+  for (var parentsA = getParents(nodeA), parentsB = getParents(nodeB), i = 0; i < parentsA.length; i += 1) {
+    var currentParent = parentsA[i];
+    if (parentsB.indexOf(currentParent) >= 0)
+      return currentParent;
+  }
+  return !1;
+}, getTopCommonParent = function(baseActiveElement, leftEntry, rightEntries) {
+  var activeElements = asArray(baseActiveElement), leftEntries = asArray(leftEntry), activeElement = activeElements[0], topCommon = !1;
+  return leftEntries.filter(Boolean).forEach(function(entry) {
+    topCommon = getCommonParent(topCommon || entry, entry) || topCommon, rightEntries.filter(Boolean).forEach(function(subEntry) {
+      var common = getCommonParent(activeElement, subEntry);
+      common && (!topCommon || contains(common, topCommon) ? topCommon = common : topCommon = getCommonParent(common, topCommon));
+    });
+  }), topCommon;
+}, allParentAutofocusables = function(entries, visibilityCache) {
+  return entries.reduce(function(acc, node) {
+    return acc.concat(parentAutofocusables(node, visibilityCache));
+  }, []);
+}, reorderNodes = function(srcNodes, dstNodes) {
+  var remap = /* @__PURE__ */ new Map();
+  return dstNodes.forEach(function(entity) {
+    return remap.set(entity.node, entity);
+  }), srcNodes.map(function(node) {
+    return remap.get(node);
+  }).filter(isDefined);
+}, focusSolver = function(topNode, lastNode) {
+  var activeElement = getActiveElement(asArray(topNode).length > 0 ? document : getFirst(topNode).ownerDocument), entries = getAllAffectedNodes(topNode).filter(isNotAGuard), commonParent = getTopCommonParent(activeElement || topNode, topNode, entries), visibilityCache = /* @__PURE__ */ new Map(), anyFocusable = getFocusableNodes(entries, visibilityCache), innerElements = anyFocusable.filter(function(_a) {
+    var node = _a.node;
+    return isNotAGuard(node);
+  });
+  if (innerElements[0]) {
+    var outerNodes = getFocusableNodes([commonParent], visibilityCache).map(function(_a) {
+      var node = _a.node;
+      return node;
+    }), orderedInnerElements = reorderNodes(outerNodes, innerElements), innerFocusables = orderedInnerElements.map(function(_a) {
+      var node = _a.node;
+      return node;
+    }), innerTabbable = orderedInnerElements.filter(function(_a) {
+      var tabIndex = _a.tabIndex;
+      return tabIndex >= 0;
+    }).map(function(_a) {
+      var node = _a.node;
+      return node;
+    }), newId = newFocus(innerFocusables, innerTabbable, outerNodes, activeElement, lastNode);
+    if (newId === NEW_FOCUS) {
+      var focusNode = (
+        // first try only tabbable, and the fallback to all focusable, as long as at least one element should be picked for focus
+        pickAutofocus(anyFocusable, innerTabbable, allParentAutofocusables(entries, visibilityCache)) || pickAutofocus(anyFocusable, innerFocusables, allParentAutofocusables(entries, visibilityCache))
+      );
+      if (focusNode)
+        return { node: focusNode };
+      console.warn("focus-lock: cannot find any node to move focus into");
+      return;
+    }
+    return newId === void 0 ? newId : orderedInnerElements[newId];
+  }
+}, expandFocusableNodes = function(topNode) {
+  var entries = getAllAffectedNodes(topNode).filter(isNotAGuard), commonParent = getTopCommonParent(topNode, topNode, entries), outerNodes = orderByTabIndex(getFocusables([commonParent], !0), !0, !0), innerElements = getFocusables(entries, !1);
+  return outerNodes.map(function(_a) {
+    var node = _a.node, index = _a.index;
+    return {
+      node,
+      index,
+      lockItem: innerElements.indexOf(node) >= 0,
+      guard: isGuard(node)
+    };
+  });
+}, focusOn = function(target, focusOptions) {
+  target && ("focus" in target && target.focus(focusOptions), "contentWindow" in target && target.contentWindow && target.contentWindow.focus());
+}, guardCount = 0, lockDisabled = !1, moveFocusInside = function(topNode, lastNode, options) {
+  options === void 0 && (options = {});
+  var focusable = focusSolver(topNode, lastNode);
+  if (!lockDisabled && focusable) {
+    if (guardCount > 2) {
+      console.error("FocusLock: focus-fighting detected. Only one focus management system could be active. See https://github.com/theKashey/focus-lock/#focus-fighting"), lockDisabled = !0, setTimeout(function() {
+        lockDisabled = !1;
+      }, 1);
+      return;
+    }
+    guardCount++, focusOn(focusable.node, options.focusOptions), guardCount--;
+  }
+};
+function weakRef(value) {
+  if (!value)
+    return null;
+  if (typeof WeakRef > "u")
+    return function() {
+      return value || null;
+    };
+  var w = value ? new WeakRef(value) : null;
+  return function() {
+    return w?.deref() || null;
+  };
+}
+var recordElementLocation = function(element) {
+  if (!element)
+    return null;
+  for (var stack = [], currentElement = element; currentElement && currentElement !== document.body; )
+    stack.push({
+      current: weakRef(currentElement),
+      parent: weakRef(currentElement.parentElement),
+      left: weakRef(currentElement.previousElementSibling),
+      right: weakRef(currentElement.nextElementSibling)
+    }), currentElement = currentElement.parentElement;
+  return {
+    element: weakRef(element),
+    stack,
+    ownerDocument: element.ownerDocument
+  };
+}, restoreFocusTo = function(location) {
+  var _a, _b, _c, _d, _e;
+  if (location)
+    for (var stack = location.stack, ownerDocument = location.ownerDocument, visibilityCache = /* @__PURE__ */ new Map(), _i = 0, stack_1 = stack; _i < stack_1.length; _i++) {
+      var line = stack_1[_i], parent_1 = (_a = line.parent) === null || _a === void 0 ? void 0 : _a.call(line);
+      if (parent_1 && ownerDocument.contains(parent_1)) {
+        for (var left = (_b = line.left) === null || _b === void 0 ? void 0 : _b.call(line), savedCurrent = line.current(), current = parent_1.contains(savedCurrent) ? savedCurrent : void 0, right = (_c = line.right) === null || _c === void 0 ? void 0 : _c.call(line), focusables = getTabbableNodes([parent_1], visibilityCache), aim = (
+          // that is element itself
+          (_e = (_d = current ?? left?.nextElementSibling) !== null && _d !== void 0 ? _d : (
+            // or somebody to the right, still close enough
+            right
+          )) !== null && _e !== void 0 ? _e : (
+            // or somebody to the left, something?
+            left
+          )
+        ); aim; ) {
+          for (var _f = 0, focusables_1 = focusables; _f < focusables_1.length; _f++) {
+            var focusable = focusables_1[_f];
+            if (aim?.contains(focusable.node))
+              return focusable.node;
+          }
+          aim = aim.nextElementSibling;
+        }
+        if (focusables.length)
+          return focusables[0].node;
+      }
+    }
+}, captureFocusRestore = function(targetElement) {
+  var location = recordElementLocation(targetElement);
+  return function() {
+    return restoreFocusTo(location);
+  };
+}, getRelativeFocusable = function(element, scope, useTabbables) {
+  if (!element || !scope)
+    return console.error("no element or scope given"), {};
+  var shards = asArray(scope);
+  if (shards.every(function(shard) {
+    return !contains(shard, element);
+  }))
+    return console.error("Active element is not contained in the scope"), {};
+  var focusables = useTabbables ? getTabbableNodes(shards, /* @__PURE__ */ new Map()) : getFocusableNodes(shards, /* @__PURE__ */ new Map()), current = focusables.findIndex(function(_a) {
+    var node = _a.node;
+    return node === element;
+  });
+  if (current !== -1)
+    return {
+      prev: focusables[current - 1],
+      next: focusables[current + 1],
+      first: focusables[0],
+      last: focusables[focusables.length - 1]
+    };
+}, getBoundary = function(shards, useTabbables) {
+  var set2 = useTabbables ? getTabbableNodes(asArray(shards), /* @__PURE__ */ new Map()) : getFocusableNodes(asArray(shards), /* @__PURE__ */ new Map());
+  return {
+    first: set2[0],
+    last: set2[set2.length - 1]
+  };
+}, defaultOptions$1 = function(options) {
+  return Object.assign({
+    scope: document.body,
+    cycle: !0,
+    onlyTabbable: !0
+  }, options);
+}, moveFocus = function(fromElement, options, cb) {
+  options === void 0 && (options = {});
+  var newOptions = defaultOptions$1(options), solution = getRelativeFocusable(fromElement, newOptions.scope, newOptions.onlyTabbable);
+  if (solution) {
+    var target = cb(solution, newOptions.cycle);
+    target && focusOn(target.node, newOptions.focusOptions);
+  }
+}, focusNextElement = function(fromElement, options) {
+  options === void 0 && (options = {}), moveFocus(fromElement, options, function(_a, cycle) {
+    var next = _a.next, first = _a.first;
+    return next || cycle && first;
+  });
+}, focusPrevElement = function(fromElement, options) {
+  options === void 0 && (options = {}), moveFocus(fromElement, options, function(_a, cycle) {
+    var prev = _a.prev, last = _a.last;
+    return prev || cycle && last;
+  });
+}, pickBoundary = function(scope, options, what) {
+  var _a, boundary = getBoundary(scope, (_a = options.onlyTabbable) !== null && _a !== void 0 ? _a : !0), node = boundary[what];
+  node && focusOn(node.node, options.focusOptions);
+}, focusFirstElement = function(scope, options) {
+  options === void 0 && (options = {}), pickBoundary(scope, options, "first");
+}, focusLastElement = function(scope, options) {
+  options === void 0 && (options = {}), pickBoundary(scope, options, "last");
+};
+function deferAction(action) {
+  setTimeout(action, 1);
+}
+var extractRef = function(ref) {
+  return ref && "current" in ref ? ref.current : ref;
+}, focusOnBody = function() {
+  return document && document.activeElement === document.body;
+}, isFreeFocus = function() {
+  return focusOnBody() || focusIsHidden();
+}, lastActiveTrap = null, lastActiveFocus = null, tryRestoreFocus = function() {
+  return null;
+}, lastPortaledElement = null, focusWasOutsideWindow = !1, windowFocused = !1, defaultWhitelist = function() {
+  return !0;
+}, focusWhitelisted = function(activeElement) {
+  return (lastActiveTrap.whiteList || defaultWhitelist)(activeElement);
+}, recordPortal = function(observerNode, portaledElement) {
+  lastPortaledElement = {
+    observerNode,
+    portaledElement
+  };
+}, focusIsPortaledPair = function(element) {
+  return lastPortaledElement && lastPortaledElement.portaledElement === element;
+};
+function autoGuard(startIndex, end, step, allNodes) {
+  var lastGuard = null, i = startIndex;
+  do {
+    var item = allNodes[i];
+    if (item.guard)
+      item.node.dataset.focusAutoGuard && (lastGuard = item);
+    else if (item.lockItem) {
+      if (i !== startIndex)
+        return;
+      lastGuard = null;
+    } else
+      break;
+  } while ((i += step) !== end);
+  lastGuard && (lastGuard.node.tabIndex = 0);
+}
+var focusWasOutside = function(crossFrameOption) {
+  return crossFrameOption ? !!focusWasOutsideWindow : focusWasOutsideWindow === "meanwhile";
+}, checkInHost = function checkInHost2(check, el, boundary) {
+  return el && (el.host === check && (!el.activeElement || boundary.contains(el.activeElement)) || el.parentNode && checkInHost2(check, el.parentNode, boundary));
+}, withinHost = function(activeElement, workingArea) {
+  return workingArea.some(function(area) {
+    return checkInHost(activeElement, area, area);
+  });
+}, getNodeFocusables = function(nodes) {
+  return getFocusableNodes(nodes, /* @__PURE__ */ new Map());
+}, isNotFocusable = function(node) {
+  return !getNodeFocusables([node.parentNode]).some(function(el) {
+    return el.node === node;
+  });
+}, activateTrap = function() {
+  var result = !1;
+  if (lastActiveTrap) {
+    var _lastActiveTrap = lastActiveTrap, observed = _lastActiveTrap.observed, persistentFocus = _lastActiveTrap.persistentFocus, autoFocus = _lastActiveTrap.autoFocus, shards = _lastActiveTrap.shards, crossFrame = _lastActiveTrap.crossFrame, focusOptions = _lastActiveTrap.focusOptions, noFocusGuards = _lastActiveTrap.noFocusGuards, workingNode = observed || lastPortaledElement && lastPortaledElement.portaledElement;
+    if (focusOnBody() && lastActiveFocus && lastActiveFocus !== document.body && (!document.body.contains(lastActiveFocus) || isNotFocusable(lastActiveFocus))) {
+      var newTarget = tryRestoreFocus();
+      newTarget && newTarget.focus();
+    }
+    var activeElement = document && document.activeElement;
+    if (workingNode) {
+      var workingArea = [workingNode].concat(shards.map(extractRef).filter(Boolean)), shouldForceRestoreFocus = function() {
+        if (!focusWasOutside(crossFrame) || !noFocusGuards || !lastActiveFocus || windowFocused)
+          return !1;
+        var nodes = getNodeFocusables(workingArea), lastIndex = nodes.findIndex(function(_ref2) {
+          var node = _ref2.node;
+          return node === lastActiveFocus;
+        });
+        return lastIndex === 0 || lastIndex === nodes.length - 1;
+      };
+      if ((!activeElement || focusWhitelisted(activeElement)) && (persistentFocus || shouldForceRestoreFocus() || !isFreeFocus() || !lastActiveFocus && autoFocus) && (workingNode && !(focusInside(workingArea) || activeElement && withinHost(activeElement, workingArea) || focusIsPortaledPair(activeElement)) && (document && !lastActiveFocus && activeElement && !autoFocus ? (activeElement.blur && activeElement.blur(), document.body.focus()) : (result = moveFocusInside(workingArea, lastActiveFocus, {
+        focusOptions
+      }), lastPortaledElement = {})), lastActiveFocus = document && document.activeElement, lastActiveFocus !== document.body && (tryRestoreFocus = captureFocusRestore(lastActiveFocus)), focusWasOutsideWindow = !1), document && activeElement !== document.activeElement && document.querySelector("[data-focus-auto-guard]")) {
+        var newActiveElement = document && document.activeElement, allNodes = expandFocusableNodes(workingArea), focusedIndex = allNodes.map(function(_ref2) {
+          var node = _ref2.node;
+          return node;
+        }).indexOf(newActiveElement);
+        focusedIndex > -1 && (allNodes.filter(function(_ref3) {
+          var guard = _ref3.guard, node = _ref3.node;
+          return guard && node.dataset.focusAutoGuard;
+        }).forEach(function(_ref4) {
+          var node = _ref4.node;
+          return node.removeAttribute("tabIndex");
+        }), autoGuard(focusedIndex, allNodes.length, 1, allNodes), autoGuard(focusedIndex, -1, -1, allNodes));
+      }
+    }
+  }
+  return result;
+}, onTrap = function(event) {
+  activateTrap() && event && (event.stopPropagation(), event.preventDefault());
+}, onBlur = function() {
+  return deferAction(activateTrap);
+}, onFocus = function(event) {
+  var source = event.target, currentNode = event.currentTarget;
+  currentNode.contains(source) || recordPortal(currentNode, source);
+}, FocusWatcher = function() {
+  return null;
+}, onWindowFocus = function() {
+  windowFocused = !0;
+}, onWindowBlur = function() {
+  windowFocused = !1, focusWasOutsideWindow = "just", deferAction(function() {
+    focusWasOutsideWindow = "meanwhile";
+  });
+}, attachHandler = function() {
+  document.addEventListener("focusin", onTrap), document.addEventListener("focusout", onBlur), window.addEventListener("focus", onWindowFocus), window.addEventListener("blur", onWindowBlur);
+}, detachHandler = function() {
+  document.removeEventListener("focusin", onTrap), document.removeEventListener("focusout", onBlur), window.removeEventListener("focus", onWindowFocus), window.removeEventListener("blur", onWindowBlur);
+};
+function reducePropsToState(propsList) {
+  return propsList.filter(function(_ref6) {
+    var disabled = _ref6.disabled;
+    return !disabled;
+  });
+}
+var focusLockAPI = {
+  moveFocusInside,
+  focusInside,
+  focusNextElement,
+  focusPrevElement,
+  focusFirstElement,
+  focusLastElement,
+  captureFocusRestore
+};
+function handleStateChangeOnClient(traps) {
+  var trap = traps.slice(-1)[0];
+  trap && !lastActiveTrap && attachHandler();
+  var lastTrap = lastActiveTrap, sameTrap = lastTrap && trap && trap.id === lastTrap.id;
+  lastActiveTrap = trap, lastTrap && !sameTrap && (lastTrap.onDeactivation(), traps.filter(function(_ref7) {
+    var id = _ref7.id;
+    return id === lastTrap.id;
+  }).length || lastTrap.returnFocus(!trap)), trap ? (lastActiveFocus = null, (!sameTrap || lastTrap.observed !== trap.observed) && trap.onActivation(focusLockAPI), activateTrap(), deferAction(activateTrap)) : (detachHandler(), lastActiveFocus = null);
+}
+mediumFocus.assignSyncMedium(onFocus);
+mediumBlur.assignMedium(onBlur);
+mediumEffect.assignMedium(function(cb) {
+  return cb(focusLockAPI);
+});
+var FocusTrap = withSideEffect(reducePropsToState, handleStateChangeOnClient)(FocusWatcher), FocusLockCombination = /* @__PURE__ */ forwardRef(function(props, ref) {
+  return /* @__PURE__ */ React__default.createElement(FocusLock, _extends({
+    sideCar: FocusTrap,
+    ref
+  }, props));
+}), _ref = FocusLock.propTypes || {}, propTypes = _objectWithoutPropertiesLoose(_ref, ["sideCar"]);
+FocusLockCombination.propTypes = process.env.NODE_ENV !== "production" ? propTypes : {};
+const millisecondsInWeek = 6048e5, constructFromSymbol = Symbol.for("constructDateFrom");
+function constructFrom(date, value) {
+  return typeof date == "function" ? date(value) : date && typeof date == "object" && constructFromSymbol in date ? date[constructFromSymbol](value) : date instanceof Date ? new date.constructor(value) : new Date(value);
+}
+function toDate(argument, context) {
+  return constructFrom(argument, argument);
+}
+function addDays(date, amount, options) {
+  const _date = toDate(date);
+  return isNaN(amount) ? constructFrom(date, NaN) : (amount && _date.setDate(_date.getDate() + amount), _date);
+}
+function addMonths(date, amount, options) {
+  const _date = toDate(date);
+  if (isNaN(amount)) return constructFrom(date, NaN);
+  if (!amount)
+    return _date;
+  const dayOfMonth = _date.getDate(), endOfDesiredMonth = constructFrom(date, _date.getTime());
+  endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
+  const daysInMonth = endOfDesiredMonth.getDate();
+  return dayOfMonth >= daysInMonth ? endOfDesiredMonth : (_date.setFullYear(
+    endOfDesiredMonth.getFullYear(),
+    endOfDesiredMonth.getMonth(),
+    dayOfMonth
+  ), _date);
+}
+let defaultOptions = {};
+function getDefaultOptions() {
+  return defaultOptions;
+}
+function startOfWeek(date, options) {
+  const defaultOptions2 = getDefaultOptions(), weekStartsOn = defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0, _date = toDate(date), day = _date.getDay(), diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  return _date.setDate(_date.getDate() - diff), _date.setHours(0, 0, 0, 0), _date;
+}
+function normalizeDates(context, ...dates) {
+  const normalize = constructFrom.bind(
+    null,
+    dates.find((date) => typeof date == "object")
+  );
+  return dates.map(normalize);
+}
+function startOfDay(date, options) {
+  const _date = toDate(date);
+  return _date.setHours(0, 0, 0, 0), _date;
+}
+function addWeeks(date, amount, options) {
+  return addDays(date, amount * 7);
+}
+function isSameDay(laterDate, earlierDate, options) {
+  const [dateLeft_, dateRight_] = normalizeDates(
+    options?.in,
+    laterDate,
+    earlierDate
+  );
+  return +startOfDay(dateLeft_) == +startOfDay(dateRight_);
+}
+function normalizeInterval(context, interval) {
+  const [start, end] = normalizeDates(context, interval.start, interval.end);
+  return { start, end };
+}
+function eachWeekOfInterval(interval, options) {
+  const { start, end } = normalizeInterval(options?.in, interval);
+  let reversed = +start > +end;
+  const startDateWeek = startOfWeek(reversed ? end : start), endDateWeek = startOfWeek(reversed ? start : end);
+  startDateWeek.setHours(15), endDateWeek.setHours(15);
+  const endTime = +endDateWeek.getTime();
+  let currentDate = startDateWeek, step = 1;
+  const dates = [];
+  for (; +currentDate <= endTime; )
+    currentDate.setHours(0), dates.push(constructFrom(start, currentDate)), currentDate = addWeeks(currentDate, step), currentDate.setHours(15);
+  return reversed ? dates.reverse() : dates;
+}
+function startOfMonth(date, options) {
+  const _date = toDate(date);
+  return _date.setDate(1), _date.setHours(0, 0, 0, 0), _date;
+}
+function getWeekYear(date, options) {
+  const _date = toDate(date), year = _date.getFullYear(), defaultOptions2 = getDefaultOptions(), firstWeekContainsDate = defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1, firstWeekOfNextYear = constructFrom(date, 0);
+  firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate), firstWeekOfNextYear.setHours(0, 0, 0, 0);
+  const startOfNextYear = startOfWeek(firstWeekOfNextYear), firstWeekOfThisYear = constructFrom(date, 0);
+  firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate), firstWeekOfThisYear.setHours(0, 0, 0, 0);
+  const startOfThisYear = startOfWeek(firstWeekOfThisYear);
+  return +_date >= +startOfNextYear ? year + 1 : +_date >= +startOfThisYear ? year : year - 1;
+}
+function startOfWeekYear(date, options) {
+  const defaultOptions2 = getDefaultOptions(), firstWeekContainsDate = defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1, year = getWeekYear(date), firstWeek = constructFrom(date, 0);
+  return firstWeek.setFullYear(year, 0, firstWeekContainsDate), firstWeek.setHours(0, 0, 0, 0), startOfWeek(firstWeek);
+}
+function getWeek(date, options) {
+  const _date = toDate(date), diff = +startOfWeek(_date) - +startOfWeekYear(_date);
+  return Math.round(diff / millisecondsInWeek) + 1;
+}
+function getDaysInMonth(date, options) {
+  const _date = toDate(date), year = _date.getFullYear(), monthIndex = _date.getMonth(), lastDayOfMonth2 = constructFrom(_date, 0);
+  return lastDayOfMonth2.setFullYear(year, monthIndex + 1, 0), lastDayOfMonth2.setHours(0, 0, 0, 0), lastDayOfMonth2.getDate();
+}
+function lastDayOfMonth(date, options) {
+  const _date = toDate(date), month = _date.getMonth();
+  return _date.setFullYear(_date.getFullYear(), month + 1, 0), _date.setHours(0, 0, 0, 0), toDate(_date);
+}
+function isSameMonth(laterDate, earlierDate, options) {
+  const [laterDate_, earlierDate_] = normalizeDates(
+    options?.in,
+    laterDate,
+    earlierDate
+  );
+  return laterDate_.getFullYear() === earlierDate_.getFullYear() && laterDate_.getMonth() === earlierDate_.getMonth();
+}
+function setMonth(date, month, options) {
+  const _date = toDate(date), year = _date.getFullYear(), day = _date.getDate(), midMonth = constructFrom(date, 0);
+  midMonth.setFullYear(year, month, 15), midMonth.setHours(0, 0, 0, 0);
+  const daysInMonth = getDaysInMonth(midMonth);
+  return _date.setMonth(month, Math.min(day, daysInMonth)), _date;
+}
+function setDate(date, dayOfMonth, options) {
+  const _date = toDate(date);
+  return _date.setDate(dayOfMonth), _date;
+}
+function setHours(date, hours, options) {
+  const _date = toDate(date);
+  return _date.setHours(hours), _date;
+}
+function setMinutes(date, minutes, options) {
+  const date_ = toDate(date);
+  return date_.setMinutes(minutes), date_;
+}
+function setYear(date, year, options) {
+  const date_ = toDate(date);
+  return isNaN(+date_) ? constructFrom(date, NaN) : (date_.setFullYear(year), date_);
+}
+function CalendarDay(props) {
+  const { date, focused, isCurrentMonth, isToday, onSelect, selected } = props, handleClick = useCallback(() => {
+    onSelect(date);
+  }, [date, onSelect]);
+  return /* @__PURE__ */ jsx("div", { "aria-selected": selected, "data-ui": "CalendarDay", children: /* @__PURE__ */ jsx(
+    Card,
+    {
+      "aria-label": date.toDateString(),
+      "aria-pressed": selected,
+      as: "button",
+      __unstable_focusRing: !0,
+      "data-weekday": !0,
+      "data-focused": focused ? "true" : "",
+      role: "button",
+      tabIndex: -1,
+      onClick: handleClick,
+      padding: 3,
+      radius: 2,
+      selected,
+      tone: isToday || selected ? "primary" : "default",
+      children: /* @__PURE__ */ jsx(
+        Text,
+        {
+          muted: !selected && !isCurrentMonth,
+          style: { textAlign: "center" },
+          weight: isCurrentMonth ? "medium" : "regular",
+          children: date.getDate()
+        }
+      )
+    }
+  ) });
+}
+const MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+], WEEK_DAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], HOURS_24 = range(0, 24), ARROW_KEYS = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"], TAIL_WEEKDAYS = [1, 2, 3, 4, 5, 6], getWeekStartsOfMonth = (date) => {
+  const firstDay = startOfMonth(date);
+  return eachWeekOfInterval({
+    start: firstDay,
+    end: lastDayOfMonth(firstDay)
+  });
+}, getWeekDaysFromWeekStarts = (weekStarts) => weekStarts.map((weekStart) => [
+  weekStart,
+  ...TAIL_WEEKDAYS.map((d) => addDays(weekStart, d))
+]), getWeeksOfMonth = (date) => getWeekDaysFromWeekStarts(getWeekStartsOfMonth(date)).map(
+  (days) => ({
+    number: getWeek(days[0]),
+    days
+  })
+);
+function CalendarMonth(props) {
+  return /* @__PURE__ */ jsx(Box, { "aria-hidden": props.hidden || !1, "data-ui": "CalendarMonth", children: /* @__PURE__ */ jsxs(Grid, { gap: 1, style: { gridTemplateColumns: "repeat(7, minmax(44px, 46px))" }, children: [
+    WEEK_DAY_NAMES.map((weekday) => /* @__PURE__ */ jsx(Box, { paddingY: 2, children: /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", style: { textAlign: "center" }, children: weekday }) }, weekday)),
+    getWeeksOfMonth(props.date).map(
+      (week, weekIdx) => week.days.map((date, dayIdx) => {
+        const focused = props.focused && isSameDay(date, props.focused), selected = props.selected && isSameDay(date, props.selected), isToday = isSameDay(date, /* @__PURE__ */ new Date()), isCurrentMonth = props.focused && isSameMonth(date, props.focused);
+        return /* @__PURE__ */ jsx(
+          CalendarDay,
+          {
+            date,
+            focused,
+            isCurrentMonth,
+            isToday,
+            onSelect: props.onSelect,
+            selected
+          },
+          `${weekIdx}-${dayIdx}`
+        );
+      })
+    )
+  ] }) });
+}
+const features = {
+  dayPresets: !1,
+  timePresets: !1
+}, LazyTextInput = React__default.forwardRef(function({ onChange, onBlur: onBlur3, onKeyPress, value, ...rest }, forwardedRef) {
+  const [inputValue, setInputValue] = React__default.useState(), handleChange = React__default.useCallback((event) => {
+    setInputValue(event.currentTarget.value);
+  }, []), checkEvent = React__default.useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (event) => {
+      event.currentTarget.value !== `${value}` && onChange && onChange(event), setInputValue(void 0);
+    },
+    [onChange, value]
+  ), handleBlur = React__default.useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (e) => {
+      checkEvent(e), onBlur3 && onBlur3(e);
+    },
+    [checkEvent, onBlur3]
+  ), handleKeyPress = React__default.useCallback(
+    (e) => {
+      e.key === "Enter" && checkEvent(e), onKeyPress && onKeyPress(e);
+    },
+    [checkEvent, onKeyPress]
+  );
+  return /* @__PURE__ */ jsx(
+    TextInput,
+    {
+      ...rest,
+      "data-testid": "date-input",
+      ref: forwardedRef,
+      value: inputValue === void 0 ? value : inputValue,
+      onChange: handleChange,
+      onBlur: handleBlur,
+      onKeyPress: handleKeyPress
+    }
+  );
+}), YearInput = ({ onChange, ...props }) => {
+  const handleChange = React__default.useCallback(
+    (event) => {
+      const numericValue = parseInt(event.currentTarget.value, 10);
+      isNaN(numericValue) || onChange(numericValue);
+    },
+    [onChange]
+  );
+  return /* @__PURE__ */ jsx(LazyTextInput, { ...props, onChange: handleChange, inputMode: "numeric" });
+}, PRESERVE_FOCUS_ELEMENT = /* @__PURE__ */ jsx(
+  "span",
+  {
+    "data-preserve-focus": !0,
+    style: { overflow: "hidden", position: "absolute", outline: "none" },
+    tabIndex: -1
+  }
+), Calendar = forwardRef(function(props, forwardedRef) {
+  const {
+    selectTime,
+    onFocusedDateChange,
+    selectedDate = /* @__PURE__ */ new Date(),
+    focusedDate = selectedDate,
+    timeStep = 1,
+    onSelect,
+    ...restProps
+  } = props, setFocusedDate = useCallback(
+    (date) => onFocusedDateChange(date),
+    [onFocusedDateChange]
+  ), setFocusedDateMonth = useCallback(
+    (month) => setFocusedDate(setDate(setMonth(focusedDate, month), 1)),
+    [focusedDate, setFocusedDate]
+  ), handleFocusedMonthChange = useCallback(
+    (e) => setFocusedDateMonth(Number(e.currentTarget.value)),
+    [setFocusedDateMonth]
+  ), moveFocusedDate = useCallback(
+    (by) => setFocusedDate(addMonths(focusedDate, by)),
+    [focusedDate, setFocusedDate]
+  ), setFocusedDateYear = useCallback(
+    (year) => setFocusedDate(setYear(focusedDate, year)),
+    [focusedDate, setFocusedDate]
+  ), handleDateChange = useCallback(
+    (date) => {
+      onSelect(setMinutes(setHours(date, selectedDate.getHours()), selectedDate.getMinutes()));
+    },
+    [onSelect, selectedDate]
+  ), handleMinutesChange = useCallback(
+    (event) => {
+      const m = Number(event.currentTarget.value);
+      onSelect(setMinutes(selectedDate, m));
+    },
+    [onSelect, selectedDate]
+  ), handleHoursChange = useCallback(
+    (event) => {
+      const m = Number(event.currentTarget.value);
+      onSelect(setHours(selectedDate, m));
+    },
+    [onSelect, selectedDate]
+  );
+  useCallback(
+    (hours, mins) => {
+      onSelect(setHours(setMinutes(selectedDate, mins), hours));
+    },
+    [onSelect, selectedDate]
+  );
+  const ref = useForwardedRef(forwardedRef), focusCurrentWeekDay = useCallback(() => {
+    ref.current?.querySelector('[data-focused="true"]')?.focus();
+  }, [ref]), handleKeyDown = useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (event) => {
+      if (ARROW_KEYS.includes(event.key)) {
+        if (event.preventDefault(), event.target.hasAttribute("data-calendar-grid")) {
+          focusCurrentWeekDay();
+          return;
+        }
+        event.key === "ArrowUp" && onFocusedDateChange(addDays(focusedDate, -7)), event.key === "ArrowDown" && onFocusedDateChange(addDays(focusedDate, 7)), event.key === "ArrowLeft" && onFocusedDateChange(addDays(focusedDate, -1)), event.key === "ArrowRight" && onFocusedDateChange(addDays(focusedDate, 1)), ref.current?.querySelector("[data-preserve-focus]")?.focus();
+      }
+    },
+    [ref, focusCurrentWeekDay, onFocusedDateChange, focusedDate]
+  );
+  useEffect(() => {
+    focusCurrentWeekDay();
+  }, [focusCurrentWeekDay]), useEffect(() => {
+    document.activeElement?.matches(
+      "[data-calendar-grid], [data-calendar-grid] [data-preserve-focus]"
+    ) && focusCurrentWeekDay();
+  }, [ref, focusCurrentWeekDay, focusedDate]), useCallback(
+    () => handleDateChange(addDays(/* @__PURE__ */ new Date(), -1)),
+    [handleDateChange]
+  ), useCallback(() => handleDateChange(/* @__PURE__ */ new Date()), [handleDateChange]), useCallback(
+    () => handleDateChange(addDays(/* @__PURE__ */ new Date(), 1)),
+    [handleDateChange]
+  );
+  const handleNowClick = useCallback(() => onSelect(/* @__PURE__ */ new Date()), [onSelect]);
+  return /* @__PURE__ */ jsxs(Box, { "data-ui": "Calendar", ...restProps, ref, children: [
+    /* @__PURE__ */ jsxs(Box, { padding: 2, children: [
+      features.dayPresets,
+      /* @__PURE__ */ jsxs(Flex, { children: [
+        /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsx(
+          CalendarMonthSelect,
+          {
+            moveFocusedDate,
+            onChange: handleFocusedMonthChange,
+            value: focusedDate?.getMonth()
+          }
+        ) }),
+        /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(
+          CalendarYearSelect,
+          {
+            moveFocusedDate,
+            onChange: setFocusedDateYear,
+            value: focusedDate.getFullYear()
+          }
+        ) })
+      ] }),
+      /* @__PURE__ */ jsxs(
+        Box,
+        {
+          "data-calendar-grid": !0,
+          onKeyDown: handleKeyDown,
+          marginTop: 2,
+          overflow: "hidden",
+          tabIndex: 0,
+          children: [
+            /* @__PURE__ */ jsx(
+              CalendarMonth,
+              {
+                date: focusedDate,
+                focused: focusedDate,
+                onSelect: handleDateChange,
+                selected: selectedDate
+              }
+            ),
+            PRESERVE_FOCUS_ELEMENT
+          ]
+        }
+      )
+    ] }),
+    selectTime && /* @__PURE__ */ jsxs(Box, { padding: 2, style: { borderTop: "1px solid var(--card-border-color)" }, children: [
+      /* @__PURE__ */ jsxs(Flex, { align: "center", children: [
+        /* @__PURE__ */ jsxs(Flex, { align: "center", flex: 1, children: [
+          /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(
+            Select,
+            {
+              "aria-label": "Select hour",
+              value: selectedDate?.getHours(),
+              onChange: handleHoursChange,
+              children: HOURS_24.map((h) => /* @__PURE__ */ jsx("option", { value: h, children: `${h}`.padStart(2, "0") }, h))
+            }
+          ) }),
+          /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { children: ":" }) }),
+          /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(
+            Select,
+            {
+              "aria-label": "Select minutes",
+              value: selectedDate?.getMinutes(),
+              onChange: handleMinutesChange,
+              children: range(0, 60, timeStep).map((m) => /* @__PURE__ */ jsx("option", { value: m, children: `${m}`.padStart(2, "0") }, m))
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Button, { text: "Set to current time", mode: "bleed", onClick: handleNowClick }) })
+      ] }),
+      features.timePresets
+    ] })
+  ] });
+});
+function CalendarMonthSelect(props) {
+  const { moveFocusedDate, onChange, value } = props, handlePrevMonthClick = useCallback(() => moveFocusedDate(-1), [moveFocusedDate]), handleNextMonthClick = useCallback(() => moveFocusedDate(1), [moveFocusedDate]);
+  return /* @__PURE__ */ jsxs(Flex, { flex: 1, children: [
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        "aria-label": "Go to previous month",
+        onClick: handlePrevMonthClick,
+        mode: "bleed",
+        icon: ChevronLeftIcon,
+        paddingX: 2,
+        radius: 0
+      }
+    ),
+    /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsx(Select, { radius: 0, value, onChange, children: MONTH_NAMES.map((m, i) => (
+      // eslint-disable-next-line react/no-array-index-key
+      /* @__PURE__ */ jsx("option", { value: i, children: m }, i)
+    )) }) }),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        "aria-label": "Go to next month",
+        mode: "bleed",
+        icon: ChevronRightIcon,
+        onClick: handleNextMonthClick,
+        paddingX: 2,
+        radius: 0
+      }
+    )
+  ] });
+}
+function CalendarYearSelect(props) {
+  const { moveFocusedDate, onChange, value } = props, handlePrevYearClick = useCallback(() => moveFocusedDate(-12), [moveFocusedDate]), handleNextYearClick = useCallback(() => moveFocusedDate(12), [moveFocusedDate]);
+  return /* @__PURE__ */ jsxs(Flex, { children: [
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        "aria-label": "Previous year",
+        onClick: handlePrevYearClick,
+        mode: "bleed",
+        icon: ChevronLeftIcon,
+        paddingX: 2,
+        radius: 0
+      }
+    ),
+    /* @__PURE__ */ jsx(YearInput, { value, onChange, radius: 0, style: { width: 65 } }),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        "aria-label": "Next year",
+        onClick: handleNextYearClick,
+        mode: "bleed",
+        icon: ChevronRightIcon,
+        paddingX: 2,
+        radius: 0
+      }
+    )
+  ] });
+}
+const DatePicker = React__default.forwardRef(function(props, ref) {
+  const { value = /* @__PURE__ */ new Date(), onChange, ...rest } = props, [focusedDate, setFocusedDay] = React__default.useState(), handleSelect = React__default.useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (nextDate) => {
+      onChange(nextDate), setFocusedDay(void 0);
+    },
+    [onChange]
+  );
+  return /* @__PURE__ */ jsx(
+    Calendar,
+    {
+      ...rest,
+      ref,
+      selectedDate: value,
+      onSelect: handleSelect,
+      focusedDate: focusedDate || value,
+      onFocusedDateChange: setFocusedDay
+    }
+  );
+}), DateTimeInput = forwardRef(function(props, ref) {
+  const { value, inputValue, onInputChange, onChange, selectTime, timeStep, ...rest } = props, [popoverRef, setPopoverRef] = useState(null), forwardedRef = useForwardedRef(ref), buttonRef = useRef(null), [isPickerOpen, setPickerOpen] = useState(!1);
+  useClickOutside(() => setPickerOpen(!1), [popoverRef]);
+  const handleDeactivation = useCallback(() => {
+    forwardedRef.current?.focus(), forwardedRef.current?.select();
+  }, [forwardedRef]), handleKeyUp = useCallback((e) => {
+    e.key === "Escape" && setPickerOpen(!1);
+  }, []), handleClick = useCallback(() => setPickerOpen(!0), []), suffix = /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(
+    Button,
+    {
+      ref: buttonRef,
+      icon: CalendarIcon,
+      mode: "bleed",
+      padding: 2,
+      onClick: handleClick,
+      style: { display: "block" },
+      "data-testid": "select-date-button"
+    }
+  ) });
+  return /* @__PURE__ */ jsx(
+    LazyTextInput,
+    {
+      ref: forwardedRef,
+      ...rest,
+      value: inputValue,
+      onChange: onInputChange,
+      suffix: isPickerOpen ? (
+        // Note: we're conditionally inserting the popover here due to an
+        // issue with popovers rendering incorrectly on subsequent renders
+        // see https://github.com/sanity-io/design/issues/519
+        /* @__PURE__ */ jsx(LayerProvider, { zOffset: 1e3, children: /* @__PURE__ */ jsx(
+          Popover,
+          {
+            constrainSize: !0,
+            "data-testid": "date-input-dialog",
+            portal: !0,
+            content: /* @__PURE__ */ jsx(Box, { overflow: "auto", children: /* @__PURE__ */ jsx(FocusLockCombination, { onDeactivation: handleDeactivation, children: /* @__PURE__ */ jsx(
+              DatePicker,
+              {
+                selectTime,
+                timeStep,
+                onKeyUp: handleKeyUp,
+                value,
+                onChange
+              }
+            ) }) }),
+            open: !0,
+            placement: "bottom",
+            ref: setPopoverRef,
+            radius: 2,
+            children: suffix
+          }
+        ) })
+      ) : suffix
+    }
+  );
+}), DEFAULT_PLACEHOLDER_TIME = /* @__PURE__ */ new Date(), CommonDateTimeInput = React__default.forwardRef(function(props, ref) {
+  const {
+    id,
+    deserialize: deserialize2,
+    formatInputValue,
+    onChange,
+    parseInputValue,
+    placeholder,
+    readOnly,
+    selectTime,
+    serialize: serialize2,
+    timeStep,
+    value,
+    ...restProps
+  } = props, [localValue, setLocalValue] = React__default.useState(null);
+  useEffect(() => {
+    setLocalValue(null);
+  }, [value]);
+  const handleDatePickerInputChange = React__default.useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (event) => {
+      const nextInputValue = event.currentTarget.value, result = nextInputValue === "" ? null : parseInputValue(nextInputValue);
+      result === null ? (onChange(null), typeof value > "u" && localValue && setLocalValue(null)) : result.isValid ? onChange(serialize2(result.date)) : setLocalValue(nextInputValue);
+    },
+    [parseInputValue, onChange, value, localValue, serialize2]
+  ), handleDatePickerChange = React__default.useCallback(
+    (nextDate) => {
+      onChange(nextDate ? serialize2(nextDate) : null);
+    },
+    [serialize2, onChange]
+  ), forwardedRef = useForwardedRef(ref), parseResult = localValue ? parseInputValue(localValue) : value ? deserialize2(value) : null, inputValue = localValue || (parseResult?.isValid ? formatInputValue(parseResult.date) : value);
+  return readOnly ? /* @__PURE__ */ jsx(TextInput, { value: inputValue, readOnly: !0, disabled: readOnly }) : /* @__PURE__ */ jsx(
+    DateTimeInput,
+    {
+      ...restProps,
+      id,
+      selectTime,
+      timeStep,
+      placeholder: placeholder || `e.g. ${formatInputValue(DEFAULT_PLACEHOLDER_TIME)}`,
+      ref: forwardedRef,
+      value: parseResult?.date,
+      inputValue: inputValue || "",
+      readOnly: !!readOnly,
+      onInputChange: handleDatePickerInputChange,
+      onChange: handleDatePickerChange,
+      customValidity: parseResult?.error
+    }
+  );
+}), VALUE_FORMAT = "YYYY-MM-DD", DEFAULT_DATE_FORMAT = VALUE_FORMAT;
+function parseOptions(options = {}) {
+  return {
+    dateFormat: options.dateFormat || DEFAULT_DATE_FORMAT,
+    calendarTodayLabel: options.calendarTodayLabel || "Today"
+  };
+}
+const deserialize = (value) => parse(value, VALUE_FORMAT), serialize = (date) => format(date, VALUE_FORMAT);
+function DateInput(props) {
+  const { id, onChange, type, value, readOnly, ...rest } = props, { dateFormat } = parseOptions(type.options), handleChange = useCallback(
+    (nextDate) => {
+      onChange(nextDate || null);
+    },
+    [onChange]
+  ), formatInputValue = useCallback((date) => format(date, dateFormat), [dateFormat]), parseInputValue = useCallback(
+    (inputValue) => parse(inputValue, dateFormat),
+    [dateFormat]
+  );
+  return /* @__PURE__ */ jsx(
+    CommonDateTimeInput,
+    {
+      id,
+      ...rest,
+      deserialize,
+      formatInputValue,
+      onChange: handleChange,
+      parseInputValue,
+      readOnly,
+      selectTime: !1,
+      serialize,
+      value
+    }
+  );
+}
+function Monthly(props) {
+  const { byweekday, setByweekday } = props, { weekday: dayNo, n: weekNo } = byweekday && Array.isArray(byweekday) ? byweekday[0] : { weekday: null, n: null }, handleChange = useCallback(
+    (event) => {
+      const { value, name } = event.currentTarget;
+      if (name == "week")
+        if (value == "")
+          setByweekday(null);
+        else {
+          const newWeekday = new Weekday(dayNo || 0, Number(value));
+          setByweekday([newWeekday]);
+        }
+      else if (name == "day") {
+        const newWeekday = new Weekday(Number(value), weekNo || 1);
+        setByweekday([newWeekday]);
+      }
+    },
+    [dayNo, setByweekday, weekNo]
+  );
+  return useEffect(() => {
+    weekNo || setByweekday(null);
+  }), /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
+    /* @__PURE__ */ jsx(Text, { style: { whiteSpace: "nowrap" }, children: "On the" }),
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Select, { name: "week", value: weekNo?.toString(), onChange: handleChange, children: [
+      /* @__PURE__ */ jsx("option", { value: "", children: "same day" }),
+      /* @__PURE__ */ jsx("option", { value: "1", children: "first" }),
+      /* @__PURE__ */ jsx("option", { value: "2", children: "second" }),
+      /* @__PURE__ */ jsx("option", { value: "3", children: "third" }),
+      /* @__PURE__ */ jsx("option", { value: "4", children: "fourth" }),
+      /* @__PURE__ */ jsx("option", { value: "5", children: "fifth" }),
+      /* @__PURE__ */ jsx("option", { value: "-1", children: "last" })
+    ] }) }),
+    weekNo && /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Select, { name: "day", value: dayNo || 0, onChange: handleChange, children: DAYS.map((day, i) => {
+      const weekday = new Weekday(i);
+      return /* @__PURE__ */ jsx("option", { value: weekday.weekday, children: day }, weekday.weekday);
+    }) }) })
+  ] });
+}
+function Weekly(props) {
+  const { byweekday, setByweekday } = props, currentWeekdays = useMemo(() => Array.isArray(byweekday) ? byweekday.map((weekday) => weekday.weekday) : [], [byweekday]), handleChange = useCallback(
+    (event) => {
+      const value = Number(event.currentTarget.value), index = currentWeekdays.indexOf(value);
+      index === -1 ? currentWeekdays.push(value) : currentWeekdays.splice(index, 1), setByweekday(
+        currentWeekdays.length ? currentWeekdays.map((currentWeekday) => new Weekday(Number(currentWeekday))) : null
+      );
+    },
+    [currentWeekdays, setByweekday]
+  );
+  return /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+    /* @__PURE__ */ jsx(Text, { style: { whiteSpace: "nowrap" }, children: "Repeats on" }),
+    /* @__PURE__ */ jsx(Grid, { columns: DAYS.length, gap: 1, children: DAYS.map((day, i) => {
+      const weekday = new Weekday(i);
+      return /* @__PURE__ */ jsx(
+        Button,
+        {
+          mode: currentWeekdays && currentWeekdays.includes(i) ? "default" : "ghost",
+          tone: currentWeekdays && currentWeekdays.includes(i) ? "primary" : "default",
+          text: weekday.toString(),
+          value: i,
+          style: { cursor: "pointer" },
+          onClick: handleChange
+        },
+        day
+      );
+    }) })
+  ] });
+}
+function CustomRule({
+  open,
+  onClose,
+  onChange,
+  initialValue,
+  startDate,
+  endDate,
+  dateTimeOptions
+}) {
+  const initialRule = useMemo(() => initialValue ? rrulestr(initialValue) : new RRule(), [initialValue]), [frequency, setFrequency] = useState(initialRule.origOptions.freq || 1), [interval, setInterval] = useState(
+    initialRule.origOptions.interval && initialRule.origOptions.interval > 0 ? initialRule.origOptions.interval : 1
+  ), [count, setCount] = useState(initialRule.origOptions.count || null), [until, setUntil] = useState(
+    initialRule.origOptions.until || null
+  ), [byweekday, setByweekday] = useState(
+    initialRule.origOptions.byweekday || null
+  ), [untilValid, setUntilValid] = useState(!0), handleChange = useCallback(
+    (event) => {
+      const { name, value } = event.currentTarget;
+      name === "freq" ? setFrequency(Number(value)) : name === "interval" ? setInterval(Number(value) > 1 ? Number(value) : 1) : name === "count" && setCount(Number(value));
+    },
+    []
+  ), getUntilDate = useCallback(() => {
+    const fromDate = new Date(startDate || Date.now());
+    return frequency === RRule.YEARLY ? fromDate.setFullYear(fromDate.getFullYear() + DEFAULT_COUNTS[frequency]) : frequency === RRule.MONTHLY ? fromDate.setMonth(fromDate.getMonth() + DEFAULT_COUNTS[frequency]) : frequency === RRule.WEEKLY ? fromDate.setDate(fromDate.getDate() + DEFAULT_COUNTS[frequency] * 7) : frequency === RRule.DAILY && fromDate.setDate(fromDate.getDate() + DEFAULT_COUNTS[frequency]), fromDate.setHours(23, 59, 59, 999), fromDate;
+  }, [frequency, startDate]), handleUntilChange = useCallback(
+    (date) => {
+      if (date) {
+        const untilDate = toDate$1(`${date}T23:59:59`);
+        endDate && untilDate < toDate$1(endDate) || startDate && untilDate < toDate$1(startDate) ? setUntilValid(!1) : setUntilValid(!0), setUntil(untilDate);
+      }
+    },
+    [endDate, startDate]
+  ), handleEndChange = useCallback(
+    (event) => {
+      const { value } = event.currentTarget;
+      if (!value)
+        setUntil(null), setCount(null);
+      else if (value == "count")
+        setCount(DEFAULT_COUNTS[frequency]), setUntil(null);
+      else if (value == "until") {
+        const untilDate = getUntilDate();
+        setUntil(untilDate), setCount(null);
+      }
+    },
+    [frequency, getUntilDate]
+  ), handleConfirm = useCallback(() => {
+    const newOptions = {
+      freq: frequency,
+      interval,
+      count: count || null,
+      until: until || null,
+      byweekday: frequency === RRule.WEEKLY || frequency === RRule.MONTHLY ? byweekday : null
+    }, newRule = new RRule(newOptions);
+    onClose(), onChange(set(newRule.toString(), ["rrule"]));
+  }, [byweekday, count, frequency, interval, onChange, onClose, until]), formatUntilValue = useCallback((date) => format$1(date, "yyyy-MM-dd"), []);
+  return open ? /* @__PURE__ */ jsx(
+    Dialog,
+    {
+      header: "Custom recurrence",
+      id: "dialog-example",
+      onClose,
+      zOffset: 1e3,
+      width: 1,
+      children: /* @__PURE__ */ jsxs(Flex, { direction: "column", children: [
+        /* @__PURE__ */ jsx(Box, { flex: 1, overflow: "auto", padding: 4, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+          /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
+            /* @__PURE__ */ jsx(Text, { style: { whiteSpace: "nowrap" }, children: "Repeat every" }),
+            /* @__PURE__ */ jsx(Box, { style: { width: "75px" }, children: /* @__PURE__ */ jsx(
+              TextInput,
+              {
+                name: "interval",
+                type: "number",
+                min: 1,
+                value: interval,
+                onChange: handleChange
+              }
+            ) }),
+            /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Select, { name: "freq", value: frequency, onChange: handleChange, children: [
+              /* @__PURE__ */ jsx("option", { value: RRule.YEARLY, children: "year(s)" }),
+              /* @__PURE__ */ jsx("option", { value: RRule.MONTHLY, children: "month(s)" }),
+              /* @__PURE__ */ jsx("option", { value: RRule.WEEKLY, children: "week(s)" }),
+              /* @__PURE__ */ jsx("option", { value: RRule.DAILY, children: "day(s)" })
+            ] }) })
+          ] }),
+          frequency === RRule.MONTHLY && /* @__PURE__ */ jsx(Monthly, { byweekday, setByweekday }),
+          frequency === RRule.WEEKLY && /* @__PURE__ */ jsx(Weekly, { byweekday, setByweekday }),
+          /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+            /* @__PURE__ */ jsx(Text, { children: "Ends" }),
+            /* @__PURE__ */ jsxs(Flex, { gap: 2, paddingY: 2, align: "center", children: [
+              /* @__PURE__ */ jsx(
+                Radio,
+                {
+                  checked: !count && !until,
+                  name: "ends",
+                  onChange: handleEndChange,
+                  value: "",
+                  id: "ends-never"
+                }
+              ),
+              /* @__PURE__ */ jsx(Text, { htmlFor: "ends-never", as: "label", children: "Never" })
+            ] }),
+            /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
+              /* @__PURE__ */ jsx(
+                Radio,
+                {
+                  checked: !!until,
+                  name: "ends",
+                  onChange: handleEndChange,
+                  value: "until",
+                  id: "ends-until"
+                }
+              ),
+              /* @__PURE__ */ jsx(Text, { htmlFor: "ends-until", as: "label", style: { width: "75px" }, children: "On" }),
+              /* @__PURE__ */ jsx(Box, { style: { width: "200px" }, children: /* @__PURE__ */ jsx(
+                DateInput,
+                {
+                  id: "until",
+                  onChange: handleUntilChange,
+                  type: {
+                    name: "until",
+                    title: "Date",
+                    options: dateTimeOptions
+                  },
+                  value: formatUntilValue(until ? new Date(until) : getUntilDate()),
+                  readOnly: !until
+                }
+              ) }),
+              !untilValid && /* @__PURE__ */ jsx(Feedback, { tone: "critical", children: /* @__PURE__ */ jsx(Text, { size: 1, children: "Until date must be after event ends" }) })
+            ] }),
+            /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
+              /* @__PURE__ */ jsx(
+                Radio,
+                {
+                  checked: !!count,
+                  name: "ends",
+                  onChange: handleEndChange,
+                  value: "count",
+                  id: "ends-count"
+                }
+              ),
+              /* @__PURE__ */ jsx(Text, { htmlFor: "ends-count", as: "label", style: { width: "75px" }, children: "After" }),
+              /* @__PURE__ */ jsx(Box, { style: { width: "75px" }, children: /* @__PURE__ */ jsx(
+                TextInput,
+                {
+                  name: "count",
+                  type: "number",
+                  value: count || DEFAULT_COUNTS[frequency],
+                  onChange: handleChange,
+                  disabled: !count
+                }
+              ) }),
+              /* @__PURE__ */ jsx(Text, { style: { whiteSpace: "nowrap" }, children: "occurrence(s)" })
+            ] })
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsx(Box, { paddingX: 4, paddingY: 3, style: { borderTop: "1px solid var(--card-border-color)" }, children: /* @__PURE__ */ jsxs(Flex, { gap: 2, justify: "flex-end", children: [
+          /* @__PURE__ */ jsx(Button, { text: "Cancel", mode: "ghost", onClick: onClose }),
+          /* @__PURE__ */ jsx(Button, { text: "Done", tone: "positive", onClick: handleConfirm, disabled: !untilValid })
+        ] }) })
+      ] })
+    }
+  ) : /* @__PURE__ */ jsx(Fragment$1, {});
+}
+function RemoveEndDate({
+  title,
+  onChange
+}) {
+  const handleUnsetClick = useCallback(() => {
+    onChange(unset(["endDate"]));
+  }, [onChange]);
+  return /* @__PURE__ */ jsx(Card, { padding: 4, radius: 2, tone: "caution", "data-ui": "Alert", children: /* @__PURE__ */ jsxs(Flex, { children: [
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { size: 1, children: /* @__PURE__ */ jsx(WarningOutlineIcon, {}) }) }),
+    /* @__PURE__ */ jsxs(Stack, { space: 3, flex: 1, marginLeft: 3, children: [
+      /* @__PURE__ */ jsxs(Text, { size: 1, weight: "semibold", children: [
+        "The ",
+        title ? upperFirst(title) : "current",
+        " field has an end date"
+      ] }),
+      /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { as: "p", muted: !0, size: 1, children: "This field has an end date value, but the end date is currently disabled for this field." }) }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          icon: TrashIcon,
+          tone: "critical",
+          text: /* @__PURE__ */ jsx(Fragment$1, { children: "Remove end date" }),
+          onClick: handleUnsetClick,
+          width: "fill"
+        }
+      )
+    ] })
+  ] }) });
+}
+function RecurringDates(props) {
+  const { onChange, members, value: currentValue, schemaType, pluginConfig } = props, { options, title } = schemaType, { defaultRecurrences, hideEndDate, hideCustom, dateTimeOptions, dateOnly, validation } = {
+    ...pluginConfig,
+    ...options
+  }, [open, setOpen] = useState(!1), onClose = useCallback(() => setOpen(!1), []), onOpen = useCallback(() => setOpen(!0), []), handleChange = useCallback(
+    (event) => {
+      const { value } = event.currentTarget;
+      value == "custom" ? onOpen() : onChange(set(value, ["rrule"]));
+    },
+    [onChange, onOpen]
+  ), invalidRecurrences = validateRRuleStrings(defaultRecurrences), startDateMember = members.find(
+    (member) => member.kind === "field" && member.name === "startDate"
+  ), endDateMember = members.find(
+    (member) => member.kind === "field" && member.name === "endDate"
+  ), rruleMember = members.find((member) => member.kind === "field" && member.name === "rrule"), availableRecurrences = [...defaultRecurrences];
+  currentValue && !availableRecurrences.includes(currentValue?.rrule) && availableRecurrences.push(currentValue?.rrule);
+  const renderProps = {
+    renderField: props.renderField,
+    renderInput: props.renderInput,
+    renderItem: props.renderItem,
+    renderPreview: props.renderPreview
+  };
+  startDateMember?.kind == "field" && (startDateMember.field.schemaType.options = {
+    ...startDateMember?.field?.schemaType.options,
+    ...dateTimeOptions
+  }, dateOnly === !0 ? startDateMember.field.schemaType.name = "date" : startDateMember.field.schemaType.name = "datetime", validation?.startDate ? startDateMember.field.schemaType.validation = (CustomValidation) => validation?.startDate?.(CustomValidation) : startDateMember.field.schemaType.validation = (DefaultRule) => DefaultRule.required(), options?.fieldTitles?.startDate && (startDateMember.field.schemaType.title = options.fieldTitles.startDate), options?.fieldDescriptions?.startDate && (startDateMember.field.schemaType.description = options.fieldDescriptions.startDate)), endDateMember?.kind == "field" && (endDateMember.field.schemaType.options = {
+    ...endDateMember?.field?.schemaType.options,
+    ...dateTimeOptions
+  }, dateOnly === !0 ? endDateMember.field.schemaType.name = "date" : endDateMember.field.schemaType.name = "datetime", validation?.endDate ? endDateMember.field.schemaType.validation = (CustomValidation) => validation?.endDate?.(CustomValidation) : endDateMember.field.schemaType.validation = (DefaultRule) => DefaultRule.min(DefaultRule.valueOfField("startDate")), options?.fieldTitles?.endDate && (endDateMember.field.schemaType.title = options.fieldTitles.endDate), options?.fieldDescriptions?.endDate && (endDateMember.field.schemaType.description = options.fieldDescriptions.endDate));
+  const hasEndDate = currentValue?.endDate;
+  return /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+    /* @__PURE__ */ jsxs(Grid, { columns: hideEndDate ? 1 : 2, gap: 3, children: [
+      hasEndDate && hideEndDate && /* @__PURE__ */ jsx(RemoveEndDate, { title, onChange }),
+      /* @__PURE__ */ jsx(Flex, { align: "flex-end", gap: 2, children: /* @__PURE__ */ jsx(Box, { flex: 1, children: startDateMember && /* @__PURE__ */ jsx(ObjectInputMember, { member: startDateMember, ...renderProps }) }) }),
+      !hideEndDate && /* @__PURE__ */ jsx(Flex, { align: "flex-end", gap: 2, children: /* @__PURE__ */ jsx(Box, { flex: 1, children: endDateMember && /* @__PURE__ */ jsx(ObjectInputMember, { member: endDateMember, ...renderProps }) }) })
+    ] }),
+    invalidRecurrences ? /* @__PURE__ */ jsx(Feedback, { tone: "critical", children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
+      /* @__PURE__ */ jsx("strong", { children: "Error:" }),
+      " An invalid RRULE string was provided in the",
+      " ",
+      /* @__PURE__ */ jsx("code", { children: "defaultRecurrences" }),
+      " array. Check plugin configuration."
+    ] }) }) : /* @__PURE__ */ jsxs(Select, { onChange: handleChange, value: currentValue?.rrule, children: [
+      /* @__PURE__ */ jsx("option", { value: "", children: "Doesn't repeat" }),
+      availableRecurrences.map((recurrence) => {
+        if (!recurrence)
+          return null;
+        const rule = rrulestr(recurrence);
+        return rule.options.until = rule?.options?.until && datetime(
+          rule?.options?.until?.getFullYear(),
+          rule?.options?.until?.getMonth() + 1,
+          rule?.options?.until?.getDate(),
+          rule?.options?.until?.getHours(),
+          rule?.options?.until?.getMinutes(),
+          rule?.options?.until?.getSeconds()
+        ), /* @__PURE__ */ jsx("option", { value: recurrence, children: upperFirst(rule.toText()) }, recurrence);
+      }),
+      !hideCustom && /* @__PURE__ */ jsx("option", { value: "custom", children: "Custom..." })
+    ] }),
+    rruleMember && /* @__PURE__ */ jsx(ObjectInputMember, { member: rruleMember, ...renderProps }),
+    /* @__PURE__ */ jsx(
+      CustomRule,
+      {
+        open,
+        onClose,
+        onChange,
+        initialValue: currentValue?.rrule,
+        startDate: startDateMember?.kind == "field" ? startDateMember?.field?.value : void 0,
+        endDate: endDateMember?.kind == "field" ? endDateMember?.field?.value : void 0,
+        dateTimeOptions
+      }
+    )
+  ] });
+}
+function RecurringDatesPreview(props) {
+  const { startDate, endDate, rrule, schemaType, pluginConfig } = props, options = schemaType?.options, { dateTimeOptions, dateOnly } = {
+    ...pluginConfig,
+    ...options
+  }, rule = rrule && rrulestr(rrule);
+  rule && (rule.options.until = rule?.options?.until && datetime(
+    rule?.options?.until?.getFullYear(),
+    rule?.options?.until?.getMonth() + 1,
+    rule?.options?.until?.getDate(),
+    rule?.options?.until?.getHours(),
+    rule?.options?.until?.getMinutes(),
+    rule?.options?.until?.getSeconds()
+  ));
+  const dateFormat = dateTimeOptions?.dateFormat || DEFAULT_DATE_FORMAT$1, timeFormat = dateTimeOptions?.timeFormat || DEFAULT_TIME_FORMAT, start = startDate ? new Date(startDate) : void 0, end = endDate ? new Date(endDate) : void 0, sameDay = start && end && start.toDateString() === end.toDateString();
+  let title = "No start date";
+  dateOnly ? (title = start ? format(start, dateFormat) : "No start date", end && !sameDay && (title += ` - ${format(end, dateFormat)}`)) : (title = start ? format(start, `${dateFormat} ${timeFormat}`) : "No start date", end && (title += ` - ${format(end, sameDay ? timeFormat : `${dateFormat} ${timeFormat}`)}`));
+  const previewProps = {
+    title,
+    subtitle: rule && upperFirst(rule.toText())
+  };
+  return props.renderDefault({ ...previewProps, ...props });
+}
+var recurringDateSchema = (config) => {
+  const { dateTimeOptions, dateOnly, validation, fieldTitles, fieldDescriptions } = config;
+  return defineField({
+    name: "recurringDates",
+    title: "Dates",
+    type: "object",
+    icon: CalendarIcon,
+    fields: [
+      defineField({
+        title: fieldTitles?.startDate || "Start Date",
+        description: fieldDescriptions?.startDate || "",
+        name: "startDate",
+        type: dateOnly ? "date" : "datetime",
+        options: dateTimeOptions,
+        validation: (Rule) => validation?.startDate ? validation.startDate(Rule) : Rule.required()
+      }),
+      defineField({
+        title: fieldTitles?.endDate || "End Date",
+        description: fieldDescriptions?.endDate || "",
+        name: "endDate",
+        type: dateOnly ? "date" : "datetime",
+        options: dateTimeOptions,
+        validation: (Rule) => validation?.endDate ? validation.endDate(Rule) : Rule.min(Rule.valueOfField("startDate"))
+      }),
+      defineField({
+        title: "Recurring event",
+        name: "recurs",
+        type: "boolean"
+      }),
+      defineField({
+        title: "RRULE",
+        name: "rrule",
+        type: "string",
+        hidden: !0
+      })
+    ],
+    components: {
+      input: (props) => RecurringDates({ ...props, pluginConfig: config }),
+      preview: (props) => RecurringDatesPreview({ ...props, pluginConfig: config })
+    },
+    preview: {
+      select: {
+        startDate: "startDate",
+        endDate: "endDate",
+        rrule: "rrule"
+      }
+    }
+  });
+};
+const recurringDates = definePlugin((config) => {
+  const pluginConfig = {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+  return {
+    name: "sanity-plugin-recurring-dates",
+    schema: {
+      types: [recurringDateSchema(pluginConfig)]
+    }
+  };
+});
+export {
+  recurringDates
+};
+//# sourceMappingURL=index.mjs.map