@bigbinary/neeto-time-zones 0.5.0 → 0.5.2

package/dist/{index-3103b741.js → index-61b4b02c.js}

@@ -1641,7 +1641,8 @@ function Button$1({
   key = "",
   timezone,
   onClick,
-  is24H
+  is24H,
+  dataCy
 }) {
   const {
     label,
@@ -1666,16 +1667,12 @@ function Button$1({
   return /* @__PURE__ */ y(
     "button",
     {
-      ...{
-        id,
-        key,
-        onClick,
-        value
-      },
+      ...{ id, key, onClick, value },
       className: `flex items-center gap-2 py-2 text-md ${customClass}`,
+      "data-cy": dataCy,
       type: "button"
     },
-    /* @__PURE__ */ y("div", { className: "min-w-0 text-left break-words grow flex space-x-1" }, hideCitiesTooltip ? label : /* @__PURE__ */ y("span", { value, title: cities }, label), isDst && /* @__PURE__ */ y("span", { value, title: "Daylight savings time applicable" }, "🌞")),
+    /* @__PURE__ */ y("div", { className: "flex min-w-0 space-x-1 text-left break-words grow" }, hideCitiesTooltip ? label : /* @__PURE__ */ y("span", { ...{ value }, title: cities }, label), isDst && /* @__PURE__ */ y("span", { ...{ value }, title: "Daylight savings time applicable" }, "🌞")),
     /* @__PURE__ */ y("span", { className: "flex items-center shrink-0" }, getCurrentTimeInTimezone(timezone.utc[0])),
     children
   );
@@ -1694,19 +1691,20 @@ function Button({
   };
   const searchBoxElementId = `${elementId}-search-box`;
   p(() => {
-    if (isOverlayVisible) {
-      const searchBox = document.getElementById(searchBoxElementId);
-      searchBox.focus();
-    }
+    if (!isOverlayVisible)
+      return;
+    const searchBox = document.getElementById(searchBoxElementId);
+    searchBox.focus();
   }, [isOverlayVisible]);
-  return /* @__PURE__ */ y("div", { className: "flex flex-col justify-between w-full text-gray-700 bg-white rounded" }, /* @__PURE__ */ y(
+  return /* @__PURE__ */ y("div", { className: "flex flex-col justify-between w-full neeto-ui-text-gray-700 neeto-ui-bg-white neeto-ui-rounded" }, /* @__PURE__ */ y(
     Button$1,
     {
+      ...{ is24H },
       onClick: handleClick,
       customClass: "px-4 ntsp-button-border",
       timezone: selectedValue,
       hideCitiesTooltip: true,
-      is24H
+      dataCy: `${elementId}-select-button`
     },
     /* @__PURE__ */ y("span", { className: "flex items-center shrink-0" }, /* @__PURE__ */ y(
       "svg",
@@ -1730,11 +1728,36 @@ function Search({ searchInput, setSearchInput, elementId }) {
       type: "text",
       placeholder: "Search",
       onInput: (event) => setSearchInput(event.target.value),
-      className: "p-2 m-2 border-2 border-blue-400 rounded shadow-lg outline-none",
-      value: searchInput
+      className: "p-2 m-2 border-2 border-blue-400 outline-none neeto-ui-rounded neeto-ui-shadow-lg",
+      value: searchInput,
+      "data-cy": `${elementId}-search-box`
     }
   );
 }
+const getFromLocalStorage = (key) => {
+  let response = null;
+  try {
+    const value = localStorage.getItem(key);
+    response = value !== null ? JSON.parse(value) : null;
+  } catch (error) {
+    response = null;
+  }
+  return response;
+};
+const setToLocalStorage = (key, value) => {
+  if (value !== null) {
+    localStorage.setItem(key, JSON.stringify(value));
+  } else
+    localStorage.removeItem(key);
+};
+const hyphenize = (value, fallbackString = "") => {
+  if (typeof value === "number")
+    return String(value);
+  if (value && typeof value === "string" && value.replace) {
+    return value.replace(/[\s_]/g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").replace(/-+/g, "-").toLowerCase();
+  }
+  return fallbackString;
+};
 const groupedOptions = [
   { "US/Canada": UsCanada },
   { America },
@@ -1757,23 +1780,1329 @@ const findBrowserTimezone = () => {
   const browserTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
   return getTimezoneObject(browserTimezone);
 };
-const DEFAULT_VALUE = findBrowserTimezone() || allTimezones[0];
+const getDefaultValue = findBrowserTimezone() || allTimezones[0];
 const valueToId = (value) => `option-${value.replaceAll(" ", "_").toLowerCase()}`;
-const createGroupedOptionButton = (group, selectedValue, handleSelect, is24H) => /* @__PURE__ */ y("div", null, group.map((groupItem, groupIndex) => {
+const getDataCy = (timezone) => {
+  if (!timezone || !timezone.label) {
+    return "";
+  }
+  let { label } = timezone;
+  if (timezone.isDst) {
+    label += "-dst";
+  }
+  return `${hyphenize(label)}-select-option`;
+};
+const createGroupedOptionButton = (group, selectedValue, handleSelect, is24H) => /* @__PURE__ */ y("div", null, group.map((groupItem) => {
   const key = Object.keys(groupItem)[0];
   const element = groupItem[key];
-  return /* @__PURE__ */ y("div", { className: "flex flex-col px-2 py-1", key: groupIndex }, /* @__PURE__ */ y("span", { className: "pb-1 font-bold uppercase text-md" }, key), element.map((timezone, index) => /* @__PURE__ */ y(
+  return /* @__PURE__ */ y("div", { className: "flex flex-col px-2 py-1", key: key.toLowerCase() }, /* @__PURE__ */ y("span", { className: "pb-1 font-bold uppercase text-md" }, key), element.map((timezone) => /* @__PURE__ */ y(
     Button$1,
     {
+      ...{ is24H, timezone },
       id: valueToId(timezone.keywords),
       onClick: handleSelect,
       customClass: `px-2 hover:bg-slate-100 ${selectedValue.keywords === timezone.keywords ? "bg-blue-300" : ""}`,
-      key: index,
-      timezone,
-      is24H
+      key: timezone.label,
+      dataCy: getDataCy(timezone)
     }
   )));
 }));
+function _isPlaceholder(a2) {
+  return a2 != null && typeof a2 === "object" && a2["@@functional/placeholder"] === true;
+}
+function _curry1(fn) {
+  return function f1(a2) {
+    if (arguments.length === 0 || _isPlaceholder(a2)) {
+      return f1;
+    } else {
+      return fn.apply(this, arguments);
+    }
+  };
+}
+function _curry2(fn) {
+  return function f2(a2, b2) {
+    switch (arguments.length) {
+      case 0:
+        return f2;
+      case 1:
+        return _isPlaceholder(a2) ? f2 : _curry1(function(_b) {
+          return fn(a2, _b);
+        });
+      default:
+        return _isPlaceholder(a2) && _isPlaceholder(b2) ? f2 : _isPlaceholder(a2) ? _curry1(function(_a) {
+          return fn(_a, b2);
+        }) : _isPlaceholder(b2) ? _curry1(function(_b) {
+          return fn(a2, _b);
+        }) : fn(a2, b2);
+    }
+  };
+}
+function _concat(set1, set2) {
+  set1 = set1 || [];
+  set2 = set2 || [];
+  var idx;
+  var len1 = set1.length;
+  var len2 = set2.length;
+  var result = [];
+  idx = 0;
+  while (idx < len1) {
+    result[result.length] = set1[idx];
+    idx += 1;
+  }
+  idx = 0;
+  while (idx < len2) {
+    result[result.length] = set2[idx];
+    idx += 1;
+  }
+  return result;
+}
+function _arity(n2, fn) {
+  switch (n2) {
+    case 0:
+      return function() {
+        return fn.apply(this, arguments);
+      };
+    case 1:
+      return function(a0) {
+        return fn.apply(this, arguments);
+      };
+    case 2:
+      return function(a0, a1) {
+        return fn.apply(this, arguments);
+      };
+    case 3:
+      return function(a0, a1, a2) {
+        return fn.apply(this, arguments);
+      };
+    case 4:
+      return function(a0, a1, a2, a3) {
+        return fn.apply(this, arguments);
+      };
+    case 5:
+      return function(a0, a1, a2, a3, a4) {
+        return fn.apply(this, arguments);
+      };
+    case 6:
+      return function(a0, a1, a2, a3, a4, a5) {
+        return fn.apply(this, arguments);
+      };
+    case 7:
+      return function(a0, a1, a2, a3, a4, a5, a6) {
+        return fn.apply(this, arguments);
+      };
+    case 8:
+      return function(a0, a1, a2, a3, a4, a5, a6, a7) {
+        return fn.apply(this, arguments);
+      };
+    case 9:
+      return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {
+        return fn.apply(this, arguments);
+      };
+    case 10:
+      return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+        return fn.apply(this, arguments);
+      };
+    default:
+      throw new Error("First argument to _arity must be a non-negative integer no greater than ten");
+  }
+}
+function _curryN(length, received, fn) {
+  return function() {
+    var combined = [];
+    var argsIdx = 0;
+    var left = length;
+    var combinedIdx = 0;
+    var hasPlaceholder = false;
+    while (combinedIdx < received.length || argsIdx < arguments.length) {
+      var result;
+      if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {
+        result = received[combinedIdx];
+      } else {
+        result = arguments[argsIdx];
+        argsIdx += 1;
+      }
+      combined[combinedIdx] = result;
+      if (!_isPlaceholder(result)) {
+        left -= 1;
+      } else {
+        hasPlaceholder = true;
+      }
+      combinedIdx += 1;
+    }
+    return !hasPlaceholder && left <= 0 ? fn.apply(this, combined) : _arity(Math.max(0, left), _curryN(length, combined, fn));
+  };
+}
+var curryN = /* @__PURE__ */ _curry2(function curryN2(length, fn) {
+  if (length === 1) {
+    return _curry1(fn);
+  }
+  return _arity(length, _curryN(length, [], fn));
+});
+const curryN$1 = curryN;
+const _isArray = Array.isArray || function _isArray2(val) {
+  return val != null && val.length >= 0 && Object.prototype.toString.call(val) === "[object Array]";
+};
+function _isTransformer(obj) {
+  return obj != null && typeof obj["@@transducer/step"] === "function";
+}
+function _dispatchable(methodNames, transducerCreator, fn) {
+  return function() {
+    if (arguments.length === 0) {
+      return fn();
+    }
+    var obj = arguments[arguments.length - 1];
+    if (!_isArray(obj)) {
+      var idx = 0;
+      while (idx < methodNames.length) {
+        if (typeof obj[methodNames[idx]] === "function") {
+          return obj[methodNames[idx]].apply(obj, Array.prototype.slice.call(arguments, 0, -1));
+        }
+        idx += 1;
+      }
+      if (_isTransformer(obj)) {
+        var transducer = transducerCreator.apply(null, Array.prototype.slice.call(arguments, 0, -1));
+        return transducer(obj);
+      }
+    }
+    return fn.apply(this, arguments);
+  };
+}
+const _xfBase = {
+  init: function() {
+    return this.xf["@@transducer/init"]();
+  },
+  result: function(result) {
+    return this.xf["@@transducer/result"](result);
+  }
+};
+function _arrayFromIterator(iter) {
+  var list = [];
+  var next;
+  while (!(next = iter.next()).done) {
+    list.push(next.value);
+  }
+  return list;
+}
+function _includesWith(pred, x2, list) {
+  var idx = 0;
+  var len = list.length;
+  while (idx < len) {
+    if (pred(x2, list[idx])) {
+      return true;
+    }
+    idx += 1;
+  }
+  return false;
+}
+function _functionName(f2) {
+  var match = String(f2).match(/^function (\w*)/);
+  return match == null ? "" : match[1];
+}
+function _has(prop, obj) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function _objectIs(a2, b2) {
+  if (a2 === b2) {
+    return a2 !== 0 || 1 / a2 === 1 / b2;
+  } else {
+    return a2 !== a2 && b2 !== b2;
+  }
+}
+const _objectIs$1 = typeof Object.is === "function" ? Object.is : _objectIs;
+var toString = Object.prototype.toString;
+var _isArguments = /* @__PURE__ */ function() {
+  return toString.call(arguments) === "[object Arguments]" ? function _isArguments2(x2) {
+    return toString.call(x2) === "[object Arguments]";
+  } : function _isArguments2(x2) {
+    return _has("callee", x2);
+  };
+}();
+const _isArguments$1 = _isArguments;
+var hasEnumBug = !/* @__PURE__ */ {
+  toString: null
+}.propertyIsEnumerable("toString");
+var nonEnumerableProps = ["constructor", "valueOf", "isPrototypeOf", "toString", "propertyIsEnumerable", "hasOwnProperty", "toLocaleString"];
+var hasArgsEnumBug = /* @__PURE__ */ function() {
+  return arguments.propertyIsEnumerable("length");
+}();
+var contains = function contains2(list, item) {
+  var idx = 0;
+  while (idx < list.length) {
+    if (list[idx] === item) {
+      return true;
+    }
+    idx += 1;
+  }
+  return false;
+};
+var keys = typeof Object.keys === "function" && !hasArgsEnumBug ? /* @__PURE__ */ _curry1(function keys2(obj) {
+  return Object(obj) !== obj ? [] : Object.keys(obj);
+}) : /* @__PURE__ */ _curry1(function keys3(obj) {
+  if (Object(obj) !== obj) {
+    return [];
+  }
+  var prop, nIdx;
+  var ks = [];
+  var checkArgsLength = hasArgsEnumBug && _isArguments$1(obj);
+  for (prop in obj) {
+    if (_has(prop, obj) && (!checkArgsLength || prop !== "length")) {
+      ks[ks.length] = prop;
+    }
+  }
+  if (hasEnumBug) {
+    nIdx = nonEnumerableProps.length - 1;
+    while (nIdx >= 0) {
+      prop = nonEnumerableProps[nIdx];
+      if (_has(prop, obj) && !contains(ks, prop)) {
+        ks[ks.length] = prop;
+      }
+      nIdx -= 1;
+    }
+  }
+  return ks;
+});
+const keys$1 = keys;
+var type = /* @__PURE__ */ _curry1(function type2(val) {
+  return val === null ? "Null" : val === void 0 ? "Undefined" : Object.prototype.toString.call(val).slice(8, -1);
+});
+const type$1 = type;
+function _uniqContentEquals(aIterator, bIterator, stackA, stackB) {
+  var a2 = _arrayFromIterator(aIterator);
+  var b2 = _arrayFromIterator(bIterator);
+  function eq(_a, _b) {
+    return _equals(_a, _b, stackA.slice(), stackB.slice());
+  }
+  return !_includesWith(function(b3, aItem) {
+    return !_includesWith(eq, aItem, b3);
+  }, b2, a2);
+}
+function _equals(a2, b2, stackA, stackB) {
+  if (_objectIs$1(a2, b2)) {
+    return true;
+  }
+  var typeA = type$1(a2);
+  if (typeA !== type$1(b2)) {
+    return false;
+  }
+  if (typeof a2["fantasy-land/equals"] === "function" || typeof b2["fantasy-land/equals"] === "function") {
+    return typeof a2["fantasy-land/equals"] === "function" && a2["fantasy-land/equals"](b2) && typeof b2["fantasy-land/equals"] === "function" && b2["fantasy-land/equals"](a2);
+  }
+  if (typeof a2.equals === "function" || typeof b2.equals === "function") {
+    return typeof a2.equals === "function" && a2.equals(b2) && typeof b2.equals === "function" && b2.equals(a2);
+  }
+  switch (typeA) {
+    case "Arguments":
+    case "Array":
+    case "Object":
+      if (typeof a2.constructor === "function" && _functionName(a2.constructor) === "Promise") {
+        return a2 === b2;
+      }
+      break;
+    case "Boolean":
+    case "Number":
+    case "String":
+      if (!(typeof a2 === typeof b2 && _objectIs$1(a2.valueOf(), b2.valueOf()))) {
+        return false;
+      }
+      break;
+    case "Date":
+      if (!_objectIs$1(a2.valueOf(), b2.valueOf())) {
+        return false;
+      }
+      break;
+    case "Error":
+      return a2.name === b2.name && a2.message === b2.message;
+    case "RegExp":
+      if (!(a2.source === b2.source && a2.global === b2.global && a2.ignoreCase === b2.ignoreCase && a2.multiline === b2.multiline && a2.sticky === b2.sticky && a2.unicode === b2.unicode)) {
+        return false;
+      }
+      break;
+  }
+  var idx = stackA.length - 1;
+  while (idx >= 0) {
+    if (stackA[idx] === a2) {
+      return stackB[idx] === b2;
+    }
+    idx -= 1;
+  }
+  switch (typeA) {
+    case "Map":
+      if (a2.size !== b2.size) {
+        return false;
+      }
+      return _uniqContentEquals(a2.entries(), b2.entries(), stackA.concat([a2]), stackB.concat([b2]));
+    case "Set":
+      if (a2.size !== b2.size) {
+        return false;
+      }
+      return _uniqContentEquals(a2.values(), b2.values(), stackA.concat([a2]), stackB.concat([b2]));
+    case "Arguments":
+    case "Array":
+    case "Object":
+    case "Boolean":
+    case "Number":
+    case "String":
+    case "Date":
+    case "Error":
+    case "RegExp":
+    case "Int8Array":
+    case "Uint8Array":
+    case "Uint8ClampedArray":
+    case "Int16Array":
+    case "Uint16Array":
+    case "Int32Array":
+    case "Uint32Array":
+    case "Float32Array":
+    case "Float64Array":
+    case "ArrayBuffer":
+      break;
+    default:
+      return false;
+  }
+  var keysA = keys$1(a2);
+  if (keysA.length !== keys$1(b2).length) {
+    return false;
+  }
+  var extendedStackA = stackA.concat([a2]);
+  var extendedStackB = stackB.concat([b2]);
+  idx = keysA.length - 1;
+  while (idx >= 0) {
+    var key = keysA[idx];
+    if (!(_has(key, b2) && _equals(b2[key], a2[key], extendedStackA, extendedStackB))) {
+      return false;
+    }
+    idx -= 1;
+  }
+  return true;
+}
+var equals = /* @__PURE__ */ _curry2(function equals2(a2, b2) {
+  return _equals(a2, b2, [], []);
+});
+const equals$1 = equals;
+function _map(fn, functor) {
+  var idx = 0;
+  var len = functor.length;
+  var result = Array(len);
+  while (idx < len) {
+    result[idx] = fn(functor[idx]);
+    idx += 1;
+  }
+  return result;
+}
+function _arrayReduce(reducer, acc, list) {
+  var index = 0;
+  var length = list.length;
+  while (index < length) {
+    acc = reducer(acc, list[index]);
+    index += 1;
+  }
+  return acc;
+}
+function _isObject(x2) {
+  return Object.prototype.toString.call(x2) === "[object Object]";
+}
+var XMap = /* @__PURE__ */ function() {
+  function XMap2(f2, xf) {
+    this.xf = xf;
+    this.f = f2;
+  }
+  XMap2.prototype["@@transducer/init"] = _xfBase.init;
+  XMap2.prototype["@@transducer/result"] = _xfBase.result;
+  XMap2.prototype["@@transducer/step"] = function(result, input) {
+    return this.xf["@@transducer/step"](result, this.f(input));
+  };
+  return XMap2;
+}();
+var _xmap = function _xmap2(f2) {
+  return function(xf) {
+    return new XMap(f2, xf);
+  };
+};
+const _xmap$1 = _xmap;
+var map = /* @__PURE__ */ _curry2(
+  /* @__PURE__ */ _dispatchable(["fantasy-land/map", "map"], _xmap$1, function map2(fn, functor) {
+    switch (Object.prototype.toString.call(functor)) {
+      case "[object Function]":
+        return curryN$1(functor.length, function() {
+          return fn.call(this, functor.apply(this, arguments));
+        });
+      case "[object Object]":
+        return _arrayReduce(function(acc, key) {
+          acc[key] = fn(functor[key]);
+          return acc;
+        }, {}, keys$1(functor));
+      default:
+        return _map(fn, functor);
+    }
+  })
+);
+const map$1 = map;
+function _isString(x2) {
+  return Object.prototype.toString.call(x2) === "[object String]";
+}
+var _isArrayLike = /* @__PURE__ */ _curry1(function isArrayLike(x2) {
+  if (_isArray(x2)) {
+    return true;
+  }
+  if (!x2) {
+    return false;
+  }
+  if (typeof x2 !== "object") {
+    return false;
+  }
+  if (_isString(x2)) {
+    return false;
+  }
+  if (x2.length === 0) {
+    return true;
+  }
+  if (x2.length > 0) {
+    return x2.hasOwnProperty(0) && x2.hasOwnProperty(x2.length - 1);
+  }
+  return false;
+});
+const _isArrayLike$1 = _isArrayLike;
+var symIterator = typeof Symbol !== "undefined" ? Symbol.iterator : "@@iterator";
+function _createReduce(arrayReduce, methodReduce, iterableReduce) {
+  return function _reduce2(xf, acc, list) {
+    if (_isArrayLike$1(list)) {
+      return arrayReduce(xf, acc, list);
+    }
+    if (list == null) {
+      return acc;
+    }
+    if (typeof list["fantasy-land/reduce"] === "function") {
+      return methodReduce(xf, acc, list, "fantasy-land/reduce");
+    }
+    if (list[symIterator] != null) {
+      return iterableReduce(xf, acc, list[symIterator]());
+    }
+    if (typeof list.next === "function") {
+      return iterableReduce(xf, acc, list);
+    }
+    if (typeof list.reduce === "function") {
+      return methodReduce(xf, acc, list, "reduce");
+    }
+    throw new TypeError("reduce: list must be array or iterable");
+  };
+}
+function _iterableReduce(reducer, acc, iter) {
+  var step = iter.next();
+  while (!step.done) {
+    acc = reducer(acc, step.value);
+    step = iter.next();
+  }
+  return acc;
+}
+function _methodReduce(reducer, acc, obj, methodName) {
+  return obj[methodName](reducer, acc);
+}
+var _reduce = /* @__PURE__ */ _createReduce(_arrayReduce, _methodReduce, _iterableReduce);
+const _reduce$1 = _reduce;
+var ap = /* @__PURE__ */ _curry2(function ap2(applyF, applyX) {
+  return typeof applyX["fantasy-land/ap"] === "function" ? applyX["fantasy-land/ap"](applyF) : typeof applyF.ap === "function" ? applyF.ap(applyX) : typeof applyF === "function" ? function(x2) {
+    return applyF(x2)(applyX(x2));
+  } : _reduce$1(function(acc, f2) {
+    return _concat(acc, map$1(f2, applyX));
+  }, [], applyF);
+});
+const ap$1 = ap;
+var isNil = /* @__PURE__ */ _curry1(function isNil2(x2) {
+  return x2 == null;
+});
+const isNil$1 = isNil;
+var liftN = /* @__PURE__ */ _curry2(function liftN2(arity, fn) {
+  var lifted = curryN$1(arity, fn);
+  return curryN$1(arity, function() {
+    return _arrayReduce(ap$1, map$1(lifted, arguments[0]), Array.prototype.slice.call(arguments, 1));
+  });
+});
+const liftN$1 = liftN;
+var lift = /* @__PURE__ */ _curry1(function lift2(fn) {
+  return liftN$1(fn.length, fn);
+});
+const lift$1 = lift;
+var not = /* @__PURE__ */ _curry1(function not2(a2) {
+  return !a2;
+});
+const not$1 = not;
+var complement = /* @__PURE__ */ lift$1(not$1);
+const complement$1 = complement;
+var curry = /* @__PURE__ */ _curry1(function curry2(fn) {
+  return curryN$1(fn.length, fn);
+});
+const curry$1 = curry;
+function _isTypedArray(val) {
+  var type3 = Object.prototype.toString.call(val);
+  return type3 === "[object Uint8ClampedArray]" || type3 === "[object Int8Array]" || type3 === "[object Uint8Array]" || type3 === "[object Int16Array]" || type3 === "[object Uint16Array]" || type3 === "[object Int32Array]" || type3 === "[object Uint32Array]" || type3 === "[object Float32Array]" || type3 === "[object Float64Array]" || type3 === "[object BigInt64Array]" || type3 === "[object BigUint64Array]";
+}
+var empty = /* @__PURE__ */ _curry1(function empty2(x2) {
+  return x2 != null && typeof x2["fantasy-land/empty"] === "function" ? x2["fantasy-land/empty"]() : x2 != null && x2.constructor != null && typeof x2.constructor["fantasy-land/empty"] === "function" ? x2.constructor["fantasy-land/empty"]() : x2 != null && typeof x2.empty === "function" ? x2.empty() : x2 != null && x2.constructor != null && typeof x2.constructor.empty === "function" ? x2.constructor.empty() : _isArray(x2) ? [] : _isString(x2) ? "" : _isObject(x2) ? {} : _isArguments$1(x2) ? function() {
+    return arguments;
+  }() : _isTypedArray(x2) ? x2.constructor.from("") : void 0;
+});
+const empty$1 = empty;
+var isEmpty = /* @__PURE__ */ _curry1(function isEmpty2(x2) {
+  return x2 != null && equals$1(x2, empty$1(x2));
+});
+const isEmpty$1 = isEmpty;
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _iterableToArrayLimit(arr, i2) {
+  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+  if (null != _i) {
+    var _s, _e, _x, _r, _arr = [], _n = true, _d = false;
+    try {
+      if (_x = (_i = _i.call(arr)).next, 0 === i2) {
+        if (Object(_i) !== _i)
+          return;
+        _n = false;
+      } else
+        for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i2); _n = true)
+          ;
+    } catch (err) {
+      _d = true, _e = err;
+    } finally {
+      try {
+        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r))
+          return;
+      } finally {
+        if (_d)
+          throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length)
+    len = arr.length;
+  for (var i2 = 0, arr2 = new Array(len); i2 < len; i2++)
+    arr2[i2] = arr[i2];
+  return arr2;
+}
+function _unsupportedIterableToArray(o2, minLen) {
+  if (!o2)
+    return;
+  if (typeof o2 === "string")
+    return _arrayLikeToArray(o2, minLen);
+  var n2 = Object.prototype.toString.call(o2).slice(8, -1);
+  if (n2 === "Object" && o2.constructor)
+    n2 = o2.constructor.name;
+  if (n2 === "Map" || n2 === "Set")
+    return Array.from(o2);
+  if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
+    return _arrayLikeToArray(o2, minLen);
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i2) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i2) || _unsupportedIterableToArray(arr, i2) || _nonIterableRest();
+}
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof(obj);
+}
+var NOTHING = Symbol.for("immer-nothing");
+var DRAFTABLE = Symbol.for("immer-draftable");
+var DRAFT_STATE = Symbol.for("immer-state");
+var errors = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(plugin) {
+    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
+  },
+  function(thing) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(data) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(thing) {
+    return `'current' expects a draft, got: ${thing}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(thing) {
+    return `'original' expects a draft, got: ${thing}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function die(error, ...args) {
+  if (process.env.NODE_ENV !== "production") {
+    const e2 = errors[error];
+    const msg = typeof e2 === "function" ? e2.apply(null, args) : e2;
+    throw new Error(`[Immer] ${msg}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var getPrototypeOf = Object.getPrototypeOf;
+function isDraft(value) {
+  return !!value && !!value[DRAFT_STATE];
+}
+function isDraftable(value) {
+  var _a;
+  if (!value)
+    return false;
+  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!((_a = value.constructor) == null ? void 0 : _a[DRAFTABLE]) || isMap(value) || isSet(value);
+}
+var objectCtorString = Object.prototype.constructor.toString();
+function isPlainObject(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const proto = getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object)
+    return true;
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
+function each(obj, iter) {
+  if (getArchtype(obj) === 0) {
+    Object.entries(obj).forEach(([key, value]) => {
+      iter(key, value, obj);
+    });
+  } else {
+    obj.forEach((entry, index) => iter(index, entry, obj));
+  }
+}
+function getArchtype(thing) {
+  const state = thing[DRAFT_STATE];
+  return state ? state.type_ : Array.isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
+}
+function has(thing, prop) {
+  return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+}
+function set(thing, propOrOldValue, value) {
+  const t2 = getArchtype(thing);
+  if (t2 === 2)
+    thing.set(propOrOldValue, value);
+  else if (t2 === 3) {
+    thing.add(value);
+  } else
+    thing[propOrOldValue] = value;
+}
+function is(x2, y2) {
+  if (x2 === y2) {
+    return x2 !== 0 || 1 / x2 === 1 / y2;
+  } else {
+    return x2 !== x2 && y2 !== y2;
+  }
+}
+function isMap(target) {
+  return target instanceof Map;
+}
+function isSet(target) {
+  return target instanceof Set;
+}
+function latest(state) {
+  return state.copy_ || state.base_;
+}
+function shallowCopy(base, strict) {
+  if (isMap(base)) {
+    return new Map(base);
+  }
+  if (isSet(base)) {
+    return new Set(base);
+  }
+  if (Array.isArray(base))
+    return Array.prototype.slice.call(base);
+  if (!strict && isPlainObject(base)) {
+    if (!getPrototypeOf(base)) {
+      const obj = /* @__PURE__ */ Object.create(null);
+      return Object.assign(obj, base);
+    }
+    return { ...base };
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(base);
+  delete descriptors[DRAFT_STATE];
+  let keys4 = Reflect.ownKeys(descriptors);
+  for (let i2 = 0; i2 < keys4.length; i2++) {
+    const key = keys4[i2];
+    const desc = descriptors[key];
+    if (desc.writable === false) {
+      desc.writable = true;
+      desc.configurable = true;
+    }
+    if (desc.get || desc.set)
+      descriptors[key] = {
+        configurable: true,
+        writable: true,
+        // could live with !!desc.set as well here...
+        enumerable: desc.enumerable,
+        value: base[key]
+      };
+  }
+  return Object.create(getPrototypeOf(base), descriptors);
+}
+function freeze(obj, deep = false) {
+  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
+    return obj;
+  if (getArchtype(obj) > 1) {
+    obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
+  }
+  Object.freeze(obj);
+  if (deep)
+    each(obj, (_key, value) => freeze(value, true));
+  return obj;
+}
+function dontMutateFrozenCollections() {
+  die(2);
+}
+function isFrozen(obj) {
+  return Object.isFrozen(obj);
+}
+var plugins = {};
+function getPlugin(pluginKey) {
+  const plugin = plugins[pluginKey];
+  if (!plugin) {
+    die(0, pluginKey);
+  }
+  return plugin;
+}
+var currentScope;
+function getCurrentScope() {
+  return currentScope;
+}
+function createScope(parent_, immer_) {
+  return {
+    drafts_: [],
+    parent_,
+    immer_,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: true,
+    unfinalizedDrafts_: 0
+  };
+}
+function usePatchesInScope(scope, patchListener) {
+  if (patchListener) {
+    getPlugin("Patches");
+    scope.patches_ = [];
+    scope.inversePatches_ = [];
+    scope.patchListener_ = patchListener;
+  }
+}
+function revokeScope(scope) {
+  leaveScope(scope);
+  scope.drafts_.forEach(revokeDraft);
+  scope.drafts_ = null;
+}
+function leaveScope(scope) {
+  if (scope === currentScope) {
+    currentScope = scope.parent_;
+  }
+}
+function enterScope(immer2) {
+  return currentScope = createScope(currentScope, immer2);
+}
+function revokeDraft(draft) {
+  const state = draft[DRAFT_STATE];
+  if (state.type_ === 0 || state.type_ === 1)
+    state.revoke_();
+  else
+    state.revoked_ = true;
+}
+function processResult(result, scope) {
+  scope.unfinalizedDrafts_ = scope.drafts_.length;
+  const baseDraft = scope.drafts_[0];
+  const isReplaced = result !== void 0 && result !== baseDraft;
+  if (isReplaced) {
+    if (baseDraft[DRAFT_STATE].modified_) {
+      revokeScope(scope);
+      die(4);
+    }
+    if (isDraftable(result)) {
+      result = finalize(scope, result);
+      if (!scope.parent_)
+        maybeFreeze(scope, result);
+    }
+    if (scope.patches_) {
+      getPlugin("Patches").generateReplacementPatches_(
+        baseDraft[DRAFT_STATE].base_,
+        result,
+        scope.patches_,
+        scope.inversePatches_
+      );
+    }
+  } else {
+    result = finalize(scope, baseDraft, []);
+  }
+  revokeScope(scope);
+  if (scope.patches_) {
+    scope.patchListener_(scope.patches_, scope.inversePatches_);
+  }
+  return result !== NOTHING ? result : void 0;
+}
+function finalize(rootScope, value, path) {
+  if (isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  if (!state) {
+    each(
+      value,
+      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path)
+    );
+    return value;
+  }
+  if (state.scope_ !== rootScope)
+    return value;
+  if (!state.modified_) {
+    maybeFreeze(rootScope, state.base_, true);
+    return state.base_;
+  }
+  if (!state.finalized_) {
+    state.finalized_ = true;
+    state.scope_.unfinalizedDrafts_--;
+    const result = state.copy_;
+    let resultEach = result;
+    let isSet2 = false;
+    if (state.type_ === 3) {
+      resultEach = new Set(result);
+      result.clear();
+      isSet2 = true;
+    }
+    each(
+      resultEach,
+      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)
+    );
+    maybeFreeze(rootScope, result, false);
+    if (path && rootScope.patches_) {
+      getPlugin("Patches").generatePatches_(
+        state,
+        path,
+        rootScope.patches_,
+        rootScope.inversePatches_
+      );
+    }
+  }
+  return state.copy_;
+}
+function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+  if (process.env.NODE_ENV !== "production" && childValue === targetObject)
+    die(5);
+  if (isDraft(childValue)) {
+    const path = rootPath && parentState && parentState.type_ !== 3 && // Set objects are atomic since they have no keys.
+    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
+    const res = finalize(rootScope, childValue, path);
+    set(targetObject, prop, res);
+    if (isDraft(res)) {
+      rootScope.canAutoFreeze_ = false;
+    } else
+      return;
+  } else if (targetIsSet) {
+    targetObject.add(childValue);
+  }
+  if (isDraftable(childValue) && !isFrozen(childValue)) {
+    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+      return;
+    }
+    finalize(rootScope, childValue);
+    if (!parentState || !parentState.scope_.parent_)
+      maybeFreeze(rootScope, childValue);
+  }
+}
+function maybeFreeze(scope, value, deep = false) {
+  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+    freeze(value, deep);
+  }
+}
+function createProxyProxy(base, parent) {
+  const isArray = Array.isArray(base);
+  const state = {
+    type_: isArray ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: parent ? parent.scope_ : getCurrentScope(),
+    // True for both shallow and deep changes.
+    modified_: false,
+    // Used during finalization.
+    finalized_: false,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: parent,
+    // The base state.
+    base_: base,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: false
+  };
+  let target = state;
+  let traps = objectTraps;
+  if (isArray) {
+    target = [state];
+    traps = arrayTraps;
+  }
+  const { revoke, proxy } = Proxy.revocable(target, traps);
+  state.draft_ = proxy;
+  state.revoke_ = revoke;
+  return proxy;
+}
+var objectTraps = {
+  get(state, prop) {
+    if (prop === DRAFT_STATE)
+      return state;
+    const source = latest(state);
+    if (!has(source, prop)) {
+      return readPropFromProto(state, source, prop);
+    }
+    const value = source[prop];
+    if (state.finalized_ || !isDraftable(value)) {
+      return value;
+    }
+    if (value === peek(state.base_, prop)) {
+      prepareCopy(state);
+      return state.copy_[prop] = createProxy(value, state);
+    }
+    return value;
+  },
+  has(state, prop) {
+    return prop in latest(state);
+  },
+  ownKeys(state) {
+    return Reflect.ownKeys(latest(state));
+  },
+  set(state, prop, value) {
+    const desc = getDescriptorFromProto(latest(state), prop);
+    if (desc == null ? void 0 : desc.set) {
+      desc.set.call(state.draft_, value);
+      return true;
+    }
+    if (!state.modified_) {
+      const current2 = peek(latest(state), prop);
+      const currentState = current2 == null ? void 0 : current2[DRAFT_STATE];
+      if (currentState && currentState.base_ === value) {
+        state.copy_[prop] = value;
+        state.assigned_[prop] = false;
+        return true;
+      }
+      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
+        return true;
+      prepareCopy(state);
+      markChanged(state);
+    }
+    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
+    (value !== void 0 || prop in state.copy_) || // special case: NaN
+    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
+      return true;
+    state.copy_[prop] = value;
+    state.assigned_[prop] = true;
+    return true;
+  },
+  deleteProperty(state, prop) {
+    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+      state.assigned_[prop] = false;
+      prepareCopy(state);
+      markChanged(state);
+    } else {
+      delete state.assigned_[prop];
+    }
+    if (state.copy_) {
+      delete state.copy_[prop];
+    }
+    return true;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(state, prop) {
+    const owner = latest(state);
+    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+    if (!desc)
+      return desc;
+    return {
+      writable: true,
+      configurable: state.type_ !== 1 || prop !== "length",
+      enumerable: desc.enumerable,
+      value: owner[prop]
+    };
+  },
+  defineProperty() {
+    die(11);
+  },
+  getPrototypeOf(state) {
+    return getPrototypeOf(state.base_);
+  },
+  setPrototypeOf() {
+    die(12);
+  }
+};
+var arrayTraps = {};
+each(objectTraps, (key, fn) => {
+  arrayTraps[key] = function() {
+    arguments[0] = arguments[0][0];
+    return fn.apply(this, arguments);
+  };
+});
+arrayTraps.deleteProperty = function(state, prop) {
+  if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop)))
+    die(13);
+  return arrayTraps.set.call(this, state, prop, void 0);
+};
+arrayTraps.set = function(state, prop, value) {
+  if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop)))
+    die(14);
+  return objectTraps.set.call(this, state[0], prop, value, state[0]);
+};
+function peek(draft, prop) {
+  const state = draft[DRAFT_STATE];
+  const source = state ? latest(state) : draft;
+  return source[prop];
+}
+function readPropFromProto(state, source, prop) {
+  var _a;
+  const desc = getDescriptorFromProto(source, prop);
+  return desc ? `value` in desc ? desc.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    (_a = desc.get) == null ? void 0 : _a.call(state.draft_)
+  ) : void 0;
+}
+function getDescriptorFromProto(source, prop) {
+  if (!(prop in source))
+    return void 0;
+  let proto = getPrototypeOf(source);
+  while (proto) {
+    const desc = Object.getOwnPropertyDescriptor(proto, prop);
+    if (desc)
+      return desc;
+    proto = getPrototypeOf(proto);
+  }
+  return void 0;
+}
+function markChanged(state) {
+  if (!state.modified_) {
+    state.modified_ = true;
+    if (state.parent_) {
+      markChanged(state.parent_);
+    }
+  }
+}
+function prepareCopy(state) {
+  if (!state.copy_) {
+    state.copy_ = shallowCopy(
+      state.base_,
+      state.scope_.immer_.useStrictShallowCopy_
+    );
+  }
+}
+var Immer2 = class {
+  constructor(config) {
+    this.autoFreeze_ = true;
+    this.useStrictShallowCopy_ = false;
+    this.produce = (base, recipe, patchListener) => {
+      if (typeof base === "function" && typeof recipe !== "function") {
+        const defaultBase = recipe;
+        recipe = base;
+        const self = this;
+        return function curriedProduce(base2 = defaultBase, ...args) {
+          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+        };
+      }
+      if (typeof recipe !== "function")
+        die(6);
+      if (patchListener !== void 0 && typeof patchListener !== "function")
+        die(7);
+      let result;
+      if (isDraftable(base)) {
+        const scope = enterScope(this);
+        const proxy = createProxy(base, void 0);
+        let hasError = true;
+        try {
+          result = recipe(proxy);
+          hasError = false;
+        } finally {
+          if (hasError)
+            revokeScope(scope);
+          else
+            leaveScope(scope);
+        }
+        usePatchesInScope(scope, patchListener);
+        return processResult(result, scope);
+      } else if (!base || typeof base !== "object") {
+        result = recipe(base);
+        if (result === void 0)
+          result = base;
+        if (result === NOTHING)
+          result = void 0;
+        if (this.autoFreeze_)
+          freeze(result, true);
+        if (patchListener) {
+          const p2 = [];
+          const ip = [];
+          getPlugin("Patches").generateReplacementPatches_(base, result, p2, ip);
+          patchListener(p2, ip);
+        }
+        return result;
+      } else
+        die(1, base);
+    };
+    this.produceWithPatches = (base, recipe) => {
+      if (typeof base === "function") {
+        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+      }
+      let patches, inversePatches;
+      const result = this.produce(base, recipe, (p2, ip) => {
+        patches = p2;
+        inversePatches = ip;
+      });
+      return [result, patches, inversePatches];
+    };
+    if (typeof (config == null ? void 0 : config.autoFreeze) === "boolean")
+      this.setAutoFreeze(config.autoFreeze);
+    if (typeof (config == null ? void 0 : config.useStrictShallowCopy) === "boolean")
+      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+  }
+  createDraft(base) {
+    if (!isDraftable(base))
+      die(8);
+    if (isDraft(base))
+      base = current(base);
+    const scope = enterScope(this);
+    const proxy = createProxy(base, void 0);
+    proxy[DRAFT_STATE].isManual_ = true;
+    leaveScope(scope);
+    return proxy;
+  }
+  finishDraft(draft, patchListener) {
+    const state = draft && draft[DRAFT_STATE];
+    if (!state || !state.isManual_)
+      die(9);
+    const { scope_: scope } = state;
+    usePatchesInScope(scope, patchListener);
+    return processResult(void 0, scope);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(value) {
+    this.autoFreeze_ = value;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(value) {
+    this.useStrictShallowCopy_ = value;
+  }
+  applyPatches(base, patches) {
+    let i2;
+    for (i2 = patches.length - 1; i2 >= 0; i2--) {
+      const patch = patches[i2];
+      if (patch.path.length === 0 && patch.op === "replace") {
+        base = patch.value;
+        break;
+      }
+    }
+    if (i2 > -1) {
+      patches = patches.slice(i2 + 1);
+    }
+    const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+    if (isDraft(base)) {
+      return applyPatchesImpl(base, patches);
+    }
+    return this.produce(
+      base,
+      (draft) => applyPatchesImpl(draft, patches)
+    );
+  }
+};
+function createProxy(value, parent) {
+  const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+  const scope = parent ? parent.scope_ : getCurrentScope();
+  scope.drafts_.push(draft);
+  return draft;
+}
+function current(value) {
+  if (!isDraft(value))
+    die(10, value);
+  return currentImpl(value);
+}
+function currentImpl(value) {
+  if (!isDraftable(value) || isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  let copy;
+  if (state) {
+    if (!state.modified_)
+      return state.base_;
+    state.finalized_ = true;
+    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+  } else {
+    copy = shallowCopy(value, true);
+  }
+  each(copy, (key, childValue) => {
+    set(copy, key, currentImpl(childValue));
+  });
+  if (state) {
+    state.finalized_ = false;
+  }
+  return copy;
+}
+var immer = new Immer2();
+immer.produce;
+immer.produceWithPatches.bind(
+  immer
+);
+immer.setAutoFreeze.bind(immer);
+immer.setUseStrictShallowCopy.bind(immer);
+immer.applyPatches.bind(immer);
+immer.createDraft.bind(immer);
+immer.finishDraft.bind(immer);
+var nullSafe = function nullSafe2(func) {
+  return (
+    // @ts-ignore
+    curryN$1(func.length, function() {
+      var _ref;
+      var dataArg = (_ref = func.length - 1, _ref < 0 || arguments.length <= _ref ? void 0 : arguments[_ref]);
+      return isNil$1(dataArg) ? dataArg : func.apply(void 0, arguments);
+    })
+  );
+};
+var noop = function noop2() {
+};
+var isNotEmpty = /* @__PURE__ */ complement$1(isEmpty$1);
+var notEquals = /* @__PURE__ */ curry$1(function(x2, y2) {
+  return x2 !== y2;
+});
+var isNot = notEquals;
+var filterNonNull = function filterNonNull2(object) {
+  return Object.fromEntries(Object.entries(object).filter(function(_ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2), v2 = _ref6[1];
+    return !isNil$1(v2);
+  }).map(function(_ref7) {
+    var _ref8 = _slicedToArray(_ref7, 2), k2 = _ref8[0], v2 = _ref8[1];
+    return [k2, _typeof(v2) === "object" && !Array.isArray(v2) ? filterNonNull2(v2) : v2];
+  }));
+};
+nullSafe(filterNonNull);
 const filterTimezones = (inputValue) => {
   if (inputValue === "") {
     return groupedOptions;
@@ -1783,9 +3112,9 @@ const filterTimezones = (inputValue) => {
     const element = group[key].filter(
       (timezone) => timezone.label.toLowerCase().includes(inputValue.toLowerCase()) || timezone.keywords.toLowerCase().includes(inputValue.toLowerCase())
     );
-    return element.length > 0 ? { [key]: element } : null;
+    return isNotEmpty(element) ? { [key]: element } : null;
   });
-  return filteredOptions.filter((group) => group !== null);
+  return filteredOptions.filter(isNot(null));
 };
 function Options({
   elementId,
@@ -1823,8 +3152,7 @@ function Options({
 }
 function Switch({
   id = "ntsp-switch",
-  onChange = () => {
-  },
+  onChange = noop,
   labelRight = "Toggle switch",
   labelLeft = "Toggle switch",
   defaultValue = false
@@ -1836,33 +3164,17 @@ function Switch({
     setIsChecked(checked);
     onChange(checked);
   };
-  return /* @__PURE__ */ y("label", { htmlFor: id, className: "flex items-center space-x-1 cursor-pointer" }, /* @__PURE__ */ y("span", { className: `ml-3 text-sm text-gray-700 ${labelLeftBold}` }, labelLeft), /* @__PURE__ */ y("span", { className: "relative" }, /* @__PURE__ */ y(
+  return /* @__PURE__ */ y("label", { htmlFor: id, className: "flex items-center space-x-1 cursor-pointer" }, /* @__PURE__ */ y("span", { className: `ml-3 text-sm neeto-ui-text-gray-700 ${labelLeftBold}` }, labelLeft), /* @__PURE__ */ y("span", { className: "relative" }, /* @__PURE__ */ y(
     "input",
     {
       type: "checkbox",
-      id,
+      ...{ id },
       className: "sr-only",
       checked: isChecked,
       onChange: handleChange
     }
-  ), /* @__PURE__ */ y("span", { className: "block w-10 h-6 bg-gray-600 rounded-full" }), /* @__PURE__ */ y("span", { className: "absolute w-4 h-4 transition bg-white rounded-full dot left-1 top-1" })), /* @__PURE__ */ y("span", { className: `ml-3 text-sm text-gray-700 ${labelRightBold}` }, labelRight));
+  ), /* @__PURE__ */ y("span", { className: "block w-10 h-6 neeto-ui-bg-gray-600 neeto-ui-rounded-full" }), /* @__PURE__ */ y("span", { className: "absolute w-4 h-4 transition neeto-ui-bg-white neeto-ui-rounded-full dot left-1 top-1" })), /* @__PURE__ */ y("span", { className: `ml-3 text-sm neeto-ui-text-gray-700 ${labelRightBold}` }, labelRight));
 }
-const getFromLocalStorage = (key) => {
-  let response = null;
-  try {
-    const value = localStorage.getItem(key);
-    response = value !== null ? JSON.parse(value) : null;
-  } catch (error) {
-    response = null;
-  }
-  return response;
-};
-const setToLocalStorage = (key, value) => {
-  if (value !== null) {
-    localStorage.setItem(key, JSON.stringify(value));
-  } else
-    localStorage.removeItem(key);
-};
 function OptionsContainer({
   className,
   is24H,
@@ -1880,20 +3192,20 @@ function OptionsContainer({
   return /* @__PURE__ */ y(
     "div",
     {
-      className: `w-full px-2 py-4 flex flex-col text-gray-700 bg-white border border-gray-300 rounded shadow h-80 ${className}`
+      className: `w-full px-2 py-4 flex flex-col neeto-ui-text-gray-700 neeto-ui-bg-white border neeto-ui-border-gray-300 neeto-ui-rounded shadow h-80 ${className}`
     },
     /* @__PURE__ */ y(Search, { ...{ elementId, searchInput, setSearchInput } }),
-    /* @__PURE__ */ y("div", { className: "flex items-center justify-between w-full pb-2 pr-4 mb-1 shadow-sm gap-x-4" }, /* @__PURE__ */ y("span", null), /* @__PURE__ */ y(Switch, { defaultValue: is24H, labelRight: "24H", labelLeft: "AM/PM", onChange: handleTimeFormatChange })),
+    /* @__PURE__ */ y("div", { className: "flex items-center justify-between w-full pb-2 pr-4 mb-1 neeto-ui-shadow-sm gap-x-4" }, /* @__PURE__ */ y("span", null), /* @__PURE__ */ y(Switch, { defaultValue: is24H, labelRight: "24H", labelLeft: "AM/PM", onChange: handleTimeFormatChange })),
     /* @__PURE__ */ y(
       Options,
       {
         ...{
           elementId,
+          is24H,
           searchInput,
           selectedValue,
-          setSelectedValue,
           setIsOverlayVisible,
-          is24H
+          setSelectedValue
         }
       }
     )
@@ -1912,7 +3224,7 @@ function Selector({
   }
 }) {
   const [selectedValue, setSelectedValue] = h(
-    getTimezoneObject(initialValue) || DEFAULT_VALUE
+    getTimezoneObject(initialValue) || getDefaultValue
   );
   const [isOverlayVisible, setIsOverlayVisible] = h(false);
   const [is24H, setIs24H] = h(getFromLocalStorage("ntsp-24-hr-time-format") || false);
@@ -1936,34 +3248,27 @@ function Selector({
     const hourFormat = is24H ? "24H" : "12H";
     onHourFormatChange(hourFormat);
   }, [is24H]);
+  p(() => {
+    const timeZone = getTimezoneObject(initialValue) || getDefaultValue;
+    setSelectedValue(timeZone);
+  }, [initialValue]);
   return /* @__PURE__ */ y("div", { className: "ntsp", id: elementId }, /* @__PURE__ */ y(
     "div",
     {
       className: `flex flex-col relative ${className}`
     },
-    /* @__PURE__ */ y(
-      Button,
-      {
-        ...{
-          isOverlayVisible,
-          setIsOverlayVisible,
-          selectedValue,
-          elementId,
-          is24H
-        }
-      }
-    ),
+    /* @__PURE__ */ y(Button, { ...{ elementId, is24H, isOverlayVisible, selectedValue, setIsOverlayVisible } }),
     isOverlayVisible === true && /* @__PURE__ */ y(
       OptionsContainer,
       {
         className: `absolute ${top ? "bottom-16" : "top-16"}`,
         ...{
           elementId,
+          is24H,
           selectedValue,
-          setSelectedValue,
+          setIs24H,
           setIsOverlayVisible,
-          is24H,
-          setIs24H
+          setSelectedValue
         }
       }
     )