bhl-forms 0.3.2 → 0.3.3

package/dist/bhl-forms.es.js

@@ -18,16 +18,16 @@ var __spreadValues = (a3, b2) => {
 };
 var __spreadProps = (a3, b2) => __defProps(a3, __getOwnPropDescs(b2));
 var __objRest = (source, exclude) => {
-  var target = {};
+  var target2 = {};
   for (var prop in source)
     if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
+      target2[prop] = source[prop];
   if (source != null && __getOwnPropSymbols)
     for (var prop of __getOwnPropSymbols(source)) {
       if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
+        target2[prop] = source[prop];
     }
-  return target;
+  return target2;
 };
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve2, reject) => {
@@ -145,7 +145,7 @@ const onRE = /^on[^a-z]/;
 const isOn = (key) => onRE.test(key);
 const isModelListener = (key) => key.startsWith("onUpdate:");
 const extend$3 = Object.assign;
-const remove = (arr, el) => {
+const remove$1 = (arr, el) => {
   const i2 = arr.indexOf(el);
   if (i2 > -1) {
     arr.splice(i2, 1);
@@ -390,11 +390,11 @@ function resetTracking() {
   const last = trackStack.pop();
   shouldTrack = last === void 0 ? true : last;
 }
-function track(target, type, key) {
+function track(target2, type, key) {
   if (shouldTrack && activeEffect) {
-    let depsMap = targetMap.get(target);
+    let depsMap = targetMap.get(target2);
     if (!depsMap) {
-      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+      targetMap.set(target2, depsMap = /* @__PURE__ */ new Map());
     }
     let dep = depsMap.get(key);
     if (!dep) {
@@ -418,15 +418,15 @@ function trackEffects(dep, debuggerEventExtraInfo) {
     activeEffect.deps.push(dep);
   }
 }
-function trigger(target, type, key, newValue, oldValue, oldTarget) {
-  const depsMap = targetMap.get(target);
+function trigger(target2, type, key, newValue, oldValue, oldTarget) {
+  const depsMap = targetMap.get(target2);
   if (!depsMap) {
     return;
   }
   let deps = [];
   if (type === "clear") {
     deps = [...depsMap.values()];
-  } else if (key === "length" && isArray(target)) {
+  } else if (key === "length" && isArray(target2)) {
     const newLength = Number(newValue);
     depsMap.forEach((dep, key2) => {
       if (key2 === "length" || key2 >= newLength) {
@@ -439,9 +439,9 @@ function trigger(target, type, key, newValue, oldValue, oldTarget) {
     }
     switch (type) {
       case "add":
-        if (!isArray(target)) {
+        if (!isArray(target2)) {
           deps.push(depsMap.get(ITERATE_KEY));
-          if (isMap(target)) {
+          if (isMap(target2)) {
             deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
           }
         } else if (isIntegerKey(key)) {
@@ -449,15 +449,15 @@ function trigger(target, type, key, newValue, oldValue, oldTarget) {
         }
         break;
       case "delete":
-        if (!isArray(target)) {
+        if (!isArray(target2)) {
           deps.push(depsMap.get(ITERATE_KEY));
-          if (isMap(target)) {
+          if (isMap(target2)) {
             deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
           }
         }
         break;
       case "set":
-        if (isMap(target)) {
+        if (isMap(target2)) {
           deps.push(depsMap.get(ITERATE_KEY));
         }
         break;
@@ -547,17 +547,17 @@ function hasOwnProperty(key) {
   return obj.hasOwnProperty(key);
 }
 function createGetter(isReadonly2 = false, shallow = false) {
-  return function get2(target, key, receiver) {
+  return function get2(target2, key, receiver) {
     if (key === "__v_isReactive") {
       return !isReadonly2;
     } else if (key === "__v_isReadonly") {
       return isReadonly2;
     } else if (key === "__v_isShallow") {
       return shallow;
-    } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
-      return target;
+    } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target2)) {
+      return target2;
     }
-    const targetIsArray = isArray(target);
+    const targetIsArray = isArray(target2);
     if (!isReadonly2) {
       if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
         return Reflect.get(arrayInstrumentations, key, receiver);
@@ -566,12 +566,12 @@ function createGetter(isReadonly2 = false, shallow = false) {
         return hasOwnProperty;
       }
     }
-    const res = Reflect.get(target, key, receiver);
+    const res = Reflect.get(target2, key, receiver);
     if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
       return res;
     }
     if (!isReadonly2) {
-      track(target, "get", key);
+      track(target2, "get", key);
     }
     if (shallow) {
       return res;
@@ -588,8 +588,8 @@ function createGetter(isReadonly2 = false, shallow = false) {
 const set$1 = /* @__PURE__ */ createSetter();
 const shallowSet = /* @__PURE__ */ createSetter(true);
 function createSetter(shallow = false) {
-  return function set2(target, key, value, receiver) {
-    let oldValue = target[key];
+  return function set2(target2, key, value, receiver) {
+    let oldValue = target2[key];
     if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
       return false;
     }
@@ -598,42 +598,42 @@ function createSetter(shallow = false) {
         oldValue = toRaw(oldValue);
         value = toRaw(value);
       }
-      if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+      if (!isArray(target2) && isRef(oldValue) && !isRef(value)) {
         oldValue.value = value;
         return true;
       }
     }
-    const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
-    const result = Reflect.set(target, key, value, receiver);
-    if (target === toRaw(receiver)) {
+    const hadKey = isArray(target2) && isIntegerKey(key) ? Number(key) < target2.length : hasOwn(target2, key);
+    const result = Reflect.set(target2, key, value, receiver);
+    if (target2 === toRaw(receiver)) {
       if (!hadKey) {
-        trigger(target, "add", key, value);
+        trigger(target2, "add", key, value);
       } else if (hasChanged(value, oldValue)) {
-        trigger(target, "set", key, value);
+        trigger(target2, "set", key, value);
       }
     }
     return result;
   };
 }
-function deleteProperty(target, key) {
-  const hadKey = hasOwn(target, key);
-  target[key];
-  const result = Reflect.deleteProperty(target, key);
+function deleteProperty(target2, key) {
+  const hadKey = hasOwn(target2, key);
+  target2[key];
+  const result = Reflect.deleteProperty(target2, key);
   if (result && hadKey) {
-    trigger(target, "delete", key, void 0);
+    trigger(target2, "delete", key, void 0);
   }
   return result;
 }
-function has$1(target, key) {
-  const result = Reflect.has(target, key);
+function has$1(target2, key) {
+  const result = Reflect.has(target2, key);
   if (!isSymbol(key) || !builtInSymbols.has(key)) {
-    track(target, "has", key);
+    track(target2, "has", key);
   }
   return result;
 }
-function ownKeys(target) {
-  track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
-  return Reflect.ownKeys(target);
+function ownKeys(target2) {
+  track(target2, "iterate", isArray(target2) ? "length" : ITERATE_KEY);
+  return Reflect.ownKeys(target2);
 }
 const mutableHandlers = {
   get: get$1,
@@ -644,10 +644,10 @@ const mutableHandlers = {
 };
 const readonlyHandlers = {
   get: readonlyGet,
-  set(target, key) {
+  set(target2, key) {
     return true;
   },
-  deleteProperty(target, key) {
+  deleteProperty(target2, key) {
     return true;
   }
 };
@@ -657,9 +657,9 @@ const shallowReactiveHandlers = /* @__PURE__ */ extend$3({}, mutableHandlers, {
 });
 const toShallow = (value) => value;
 const getProto = (v) => Reflect.getPrototypeOf(v);
-function get$2(target, key, isReadonly2 = false, isShallow2 = false) {
-  target = target["__v_raw"];
-  const rawTarget = toRaw(target);
+function get$2(target2, key, isReadonly2 = false, isShallow2 = false) {
+  target2 = target2["__v_raw"];
+  const rawTarget = toRaw(target2);
   const rawKey = toRaw(key);
   if (!isReadonly2) {
     if (key !== rawKey) {
@@ -670,16 +670,16 @@ function get$2(target, key, isReadonly2 = false, isShallow2 = false) {
   const { has: has2 } = getProto(rawTarget);
   const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
   if (has2.call(rawTarget, key)) {
-    return wrap(target.get(key));
+    return wrap(target2.get(key));
   } else if (has2.call(rawTarget, rawKey)) {
-    return wrap(target.get(rawKey));
-  } else if (target !== rawTarget) {
-    target.get(key);
+    return wrap(target2.get(rawKey));
+  } else if (target2 !== rawTarget) {
+    target2.get(key);
   }
 }
 function has$2(key, isReadonly2 = false) {
-  const target = this["__v_raw"];
-  const rawTarget = toRaw(target);
+  const target2 = this["__v_raw"];
+  const rawTarget = toRaw(target2);
   const rawKey = toRaw(key);
   if (!isReadonly2) {
     if (key !== rawKey) {
@@ -687,86 +687,86 @@ function has$2(key, isReadonly2 = false) {
     }
     track(rawTarget, "has", rawKey);
   }
-  return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+  return key === rawKey ? target2.has(key) : target2.has(key) || target2.has(rawKey);
 }
-function size(target, isReadonly2 = false) {
-  target = target["__v_raw"];
-  !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
-  return Reflect.get(target, "size", target);
+function size(target2, isReadonly2 = false) {
+  target2 = target2["__v_raw"];
+  !isReadonly2 && track(toRaw(target2), "iterate", ITERATE_KEY);
+  return Reflect.get(target2, "size", target2);
 }
-function add$1(value) {
+function add$2(value) {
   value = toRaw(value);
-  const target = toRaw(this);
-  const proto = getProto(target);
-  const hadKey = proto.has.call(target, value);
+  const target2 = toRaw(this);
+  const proto = getProto(target2);
+  const hadKey = proto.has.call(target2, value);
   if (!hadKey) {
-    target.add(value);
-    trigger(target, "add", value, value);
+    target2.add(value);
+    trigger(target2, "add", value, value);
   }
   return this;
 }
 function set$2(key, value) {
   value = toRaw(value);
-  const target = toRaw(this);
-  const { has: has2, get: get2 } = getProto(target);
-  let hadKey = has2.call(target, key);
+  const target2 = toRaw(this);
+  const { has: has2, get: get2 } = getProto(target2);
+  let hadKey = has2.call(target2, key);
   if (!hadKey) {
     key = toRaw(key);
-    hadKey = has2.call(target, key);
+    hadKey = has2.call(target2, key);
   }
-  const oldValue = get2.call(target, key);
-  target.set(key, value);
+  const oldValue = get2.call(target2, key);
+  target2.set(key, value);
   if (!hadKey) {
-    trigger(target, "add", key, value);
+    trigger(target2, "add", key, value);
   } else if (hasChanged(value, oldValue)) {
-    trigger(target, "set", key, value);
+    trigger(target2, "set", key, value);
   }
   return this;
 }
 function deleteEntry(key) {
-  const target = toRaw(this);
-  const { has: has2, get: get2 } = getProto(target);
-  let hadKey = has2.call(target, key);
+  const target2 = toRaw(this);
+  const { has: has2, get: get2 } = getProto(target2);
+  let hadKey = has2.call(target2, key);
   if (!hadKey) {
     key = toRaw(key);
-    hadKey = has2.call(target, key);
+    hadKey = has2.call(target2, key);
   }
-  get2 ? get2.call(target, key) : void 0;
-  const result = target.delete(key);
+  get2 ? get2.call(target2, key) : void 0;
+  const result = target2.delete(key);
   if (hadKey) {
-    trigger(target, "delete", key, void 0);
+    trigger(target2, "delete", key, void 0);
   }
   return result;
 }
 function clear() {
-  const target = toRaw(this);
-  const hadItems = target.size !== 0;
-  const result = target.clear();
+  const target2 = toRaw(this);
+  const hadItems = target2.size !== 0;
+  const result = target2.clear();
   if (hadItems) {
-    trigger(target, "clear", void 0, void 0);
+    trigger(target2, "clear", void 0, void 0);
   }
   return result;
 }
 function createForEach(isReadonly2, isShallow2) {
-  return function forEach(callback, thisArg) {
+  return function forEach2(callback, thisArg) {
     const observed = this;
-    const target = observed["__v_raw"];
-    const rawTarget = toRaw(target);
+    const target2 = observed["__v_raw"];
+    const rawTarget = toRaw(target2);
     const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
     !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
-    return target.forEach((value, key) => {
+    return target2.forEach((value, key) => {
       return callback.call(thisArg, wrap(value), wrap(key), observed);
     });
   };
 }
 function createIterableMethod(method, isReadonly2, isShallow2) {
   return function(...args) {
-    const target = this["__v_raw"];
-    const rawTarget = toRaw(target);
+    const target2 = this["__v_raw"];
+    const rawTarget = toRaw(target2);
     const targetIsMap = isMap(rawTarget);
     const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
     const isKeyOnly = method === "keys" && targetIsMap;
-    const innerIterator = target[method](...args);
+    const innerIterator = target2[method](...args);
     const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
     !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
     return {
@@ -797,7 +797,7 @@ function createInstrumentations() {
       return size(this);
     },
     has: has$2,
-    add: add$1,
+    add: add$2,
     set: set$2,
     delete: deleteEntry,
     clear,
@@ -811,7 +811,7 @@ function createInstrumentations() {
       return size(this);
     },
     has: has$2,
-    add: add$1,
+    add: add$2,
     set: set$2,
     delete: deleteEntry,
     clear,
@@ -866,15 +866,15 @@ function createInstrumentations() {
 const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();
 function createInstrumentationGetter(isReadonly2, shallow) {
   const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
-  return (target, key, receiver) => {
+  return (target2, key, receiver) => {
     if (key === "__v_isReactive") {
       return !isReadonly2;
     } else if (key === "__v_isReadonly") {
       return isReadonly2;
     } else if (key === "__v_raw") {
-      return target;
+      return target2;
     }
-    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+    return Reflect.get(hasOwn(instrumentations, key) && key in target2 ? instrumentations : target2, key, receiver);
   };
 }
 const mutableCollectionHandlers = {
@@ -907,35 +907,35 @@ function targetTypeMap(rawType) {
 function getTargetType(value) {
   return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
 }
-function reactive(target) {
-  if (isReadonly(target)) {
-    return target;
+function reactive(target2) {
+  if (isReadonly(target2)) {
+    return target2;
   }
-  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+  return createReactiveObject(target2, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
 }
-function shallowReactive(target) {
-  return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
+function shallowReactive(target2) {
+  return createReactiveObject(target2, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
 }
-function readonly(target) {
-  return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+function readonly(target2) {
+  return createReactiveObject(target2, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
 }
-function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
-  if (!isObject$2(target)) {
-    return target;
+function createReactiveObject(target2, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+  if (!isObject$2(target2)) {
+    return target2;
   }
-  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
-    return target;
+  if (target2["__v_raw"] && !(isReadonly2 && target2["__v_isReactive"])) {
+    return target2;
   }
-  const existingProxy = proxyMap.get(target);
+  const existingProxy = proxyMap.get(target2);
   if (existingProxy) {
     return existingProxy;
   }
-  const targetType = getTargetType(target);
+  const targetType = getTargetType(target2);
   if (targetType === 0) {
-    return target;
+    return target2;
   }
-  const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
-  proxyMap.set(target, proxy);
+  const proxy = new Proxy(target2, targetType === 2 ? collectionHandlers : baseHandlers);
+  proxyMap.set(target2, proxy);
   return proxy;
 }
 function isReactive(value) {
@@ -1021,14 +1021,14 @@ function unref(ref2) {
   return isRef(ref2) ? ref2.value : ref2;
 }
 const shallowUnwrapHandlers = {
-  get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
-  set: (target, key, value, receiver) => {
-    const oldValue = target[key];
+  get: (target2, key, receiver) => unref(Reflect.get(target2, key, receiver)),
+  set: (target2, key, value, receiver) => {
+    const oldValue = target2[key];
     if (isRef(oldValue) && !isRef(value)) {
       oldValue.value = value;
       return true;
     } else {
-      return Reflect.set(target, key, value, receiver);
+      return Reflect.set(target2, key, value, receiver);
     }
   }
 };
@@ -1438,28 +1438,28 @@ function renderComponentRoot(instance) {
     handleError(err, instance, 1);
     result = createVNode(Comment);
   }
-  let root = result;
+  let root2 = result;
   if (fallthroughAttrs && inheritAttrs !== false) {
     const keys = Object.keys(fallthroughAttrs);
-    const { shapeFlag } = root;
+    const { shapeFlag } = root2;
     if (keys.length) {
       if (shapeFlag & (1 | 6)) {
         if (propsOptions && keys.some(isModelListener)) {
           fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
         }
-        root = cloneVNode(root, fallthroughAttrs);
+        root2 = cloneVNode(root2, fallthroughAttrs);
       }
     }
   }
   if (vnode.dirs) {
-    root = cloneVNode(root);
-    root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
+    root2 = cloneVNode(root2);
+    root2.dirs = root2.dirs ? root2.dirs.concat(vnode.dirs) : vnode.dirs;
   }
   if (vnode.transition) {
-    root.transition = vnode.transition;
+    root2.transition = vnode.transition;
   }
   {
-    result = root;
+    result = root2;
   }
   setCurrentRenderingInstance(prev);
   return result;
@@ -1707,7 +1707,7 @@ function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EM
   const unwatch = () => {
     effect.stop();
     if (instance && instance.scope) {
-      remove(instance.scope.effects, effect);
+      remove$1(instance.scope.effects, effect);
     }
   };
   if (ssrCleanup)
@@ -1775,15 +1775,15 @@ function defineComponent(options2) {
 }
 const isAsyncWrapper = (i2) => !!i2.type.__asyncLoader;
 const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
-function onActivated(hook, target) {
-  registerKeepAliveHook(hook, "a", target);
+function onActivated(hook, target2) {
+  registerKeepAliveHook(hook, "a", target2);
 }
-function onDeactivated(hook, target) {
-  registerKeepAliveHook(hook, "da", target);
+function onDeactivated(hook, target2) {
+  registerKeepAliveHook(hook, "da", target2);
 }
-function registerKeepAliveHook(hook, type, target = currentInstance) {
+function registerKeepAliveHook(hook, type, target2 = currentInstance) {
   const wrappedHook = hook.__wdc || (hook.__wdc = () => {
-    let current = target;
+    let current = target2;
     while (current) {
       if (current.isDeactivated) {
         return;
@@ -1792,33 +1792,33 @@ function registerKeepAliveHook(hook, type, target = currentInstance) {
     }
     return hook();
   });
-  injectHook(type, wrappedHook, target);
-  if (target) {
-    let current = target.parent;
+  injectHook(type, wrappedHook, target2);
+  if (target2) {
+    let current = target2.parent;
     while (current && current.parent) {
       if (isKeepAlive(current.parent.vnode)) {
-        injectToKeepAliveRoot(wrappedHook, type, target, current);
+        injectToKeepAliveRoot(wrappedHook, type, target2, current);
       }
       current = current.parent;
     }
   }
 }
-function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
+function injectToKeepAliveRoot(hook, type, target2, keepAliveRoot) {
   const injected = injectHook(type, hook, keepAliveRoot, true);
   onUnmounted(() => {
-    remove(keepAliveRoot[type], injected);
-  }, target);
+    remove$1(keepAliveRoot[type], injected);
+  }, target2);
 }
-function injectHook(type, hook, target = currentInstance, prepend = false) {
-  if (target) {
-    const hooks = target[type] || (target[type] = []);
+function injectHook(type, hook, target2 = currentInstance, prepend = false) {
+  if (target2) {
+    const hooks = target2[type] || (target2[type] = []);
     const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
-      if (target.isUnmounted) {
+      if (target2.isUnmounted) {
         return;
       }
       pauseTracking();
-      setCurrentInstance(target);
-      const res = callWithAsyncErrorHandling(hook, target, type, args);
+      setCurrentInstance(target2);
+      const res = callWithAsyncErrorHandling(hook, target2, type, args);
       unsetCurrentInstance();
       resetTracking();
       return res;
@@ -1831,7 +1831,7 @@ function injectHook(type, hook, target = currentInstance, prepend = false) {
     return wrappedHook;
   }
 }
-const createHook = (lifecycle) => (hook, target = currentInstance) => (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target);
+const createHook = (lifecycle) => (hook, target2 = currentInstance) => (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target2);
 const onBeforeMount = createHook("bm");
 const onMounted = createHook("m");
 const onBeforeUpdate = createHook("bu");
@@ -1841,8 +1841,8 @@ const onUnmounted = createHook("um");
 const onServerPrefetch = createHook("sp");
 const onRenderTriggered = createHook("rtg");
 const onRenderTracked = createHook("rtc");
-function onErrorCaptured(hook, target = currentInstance) {
-  injectHook("ec", hook, target);
+function onErrorCaptured(hook, target2 = currentInstance) {
+  injectHook("ec", hook, target2);
 }
 function withDirectives(vnode, directives) {
   const internalInstance = currentRenderingInstance;
@@ -2094,13 +2094,13 @@ const PublicInstanceProxyHandlers = {
     let normalizedProps;
     return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
   },
-  defineProperty(target, key, descriptor) {
+  defineProperty(target2, key, descriptor) {
     if (descriptor.get != null) {
-      target._.accessCache[key] = 0;
+      target2._.accessCache[key] = 0;
     } else if (hasOwn(descriptor, "value")) {
-      this.set(target, key, descriptor.value, null);
+      this.set(target2, key, descriptor.value, null);
     }
-    return Reflect.defineProperty(target, key, descriptor);
+    return Reflect.defineProperty(target2, key, descriptor);
   }
 };
 let shouldCacheAccess = true;
@@ -2861,7 +2861,7 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
         if (rawRef.f) {
           const existing = _isString ? hasOwn(setupState, ref2) ? setupState[ref2] : refs[ref2] : ref2.value;
           if (isUnmount) {
-            isArray(existing) && remove(existing, refValue);
+            isArray(existing) && remove$1(existing, refValue);
           } else {
             if (!isArray(existing)) {
               if (_isString) {
@@ -2904,8 +2904,8 @@ function createRenderer(options2) {
   return baseCreateRenderer(options2);
 }
 function baseCreateRenderer(options2, createHydrationFns) {
-  const target = getGlobalThis();
-  target.__VUE__ = true;
+  const target2 = getGlobalThis();
+  target2.__VUE__ = true;
   const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, insertStaticContent: hostInsertStaticContent } = options2;
   const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = !!n2.dynamicChildren) => {
     if (n1 === n2) {
@@ -4187,9 +4187,9 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
 }
 function createAttrsProxy(instance) {
   return new Proxy(instance.attrs, {
-    get(target, key) {
+    get(target2, key) {
       track(instance, "get", "$attrs");
-      return target[key];
+      return target2[key];
     }
   });
 }
@@ -4212,15 +4212,15 @@ function createSetupContext(instance) {
 function getExposeProxy(instance) {
   if (instance.exposed) {
     return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
-      get(target, key) {
-        if (key in target) {
-          return target[key];
+      get(target2, key) {
+        if (key in target2) {
+          return target2[key];
         } else if (key in publicPropertiesMap) {
           return publicPropertiesMap[key](instance);
         }
       },
-      has(target, key) {
-        return key in target || key in publicPropertiesMap;
+      has(target2, key) {
+        return key in target2 || key in publicPropertiesMap;
       }
     }));
   }
@@ -4577,10 +4577,10 @@ function onCompositionStart(e2) {
   e2.target.composing = true;
 }
 function onCompositionEnd(e2) {
-  const target = e2.target;
-  if (target.composing) {
-    target.composing = false;
-    target.dispatchEvent(new Event("input"));
+  const target2 = e2.target;
+  if (target2.composing) {
+    target2.composing = false;
+    target2.dispatchEvent(new Event("input"));
   }
 }
 const vModelText = {
@@ -4739,7 +4739,7 @@ function dbg$1() {
 const sleep = (time) => __async(void 0, null, function* () {
   return new Promise((resolve2) => setTimeout(resolve2, time));
 });
-const getCoords$1 = (elem) => {
+const getCoords$2 = (elem) => {
   let box2 = elem.getBoundingClientRect();
   return {
     top: box2.top + window.pageYOffset,
@@ -5776,13 +5776,13 @@ function getRoot$1(n) {
   }
   return node;
 }
-function createConfig$2(target = {}, parent) {
+function createConfig$2(target2 = {}, parent) {
   let node = void 0;
-  return new Proxy(target, {
+  return new Proxy(target2, {
     get(...args) {
       const prop = args[1];
       if (prop === "_t")
-        return target;
+        return target2;
       const localValue = Reflect.get(...args);
       if (localValue !== void 0)
         return localValue;
@@ -5791,8 +5791,8 @@ function createConfig$2(target = {}, parent) {
         if (parentVal !== void 0)
           return parentVal;
       }
-      if (target.rootConfig && typeof prop === "string") {
-        const rootValue = target.rootConfig[prop];
+      if (target2.rootConfig && typeof prop === "string") {
+        const rootValue = target2.rootConfig[prop];
         if (rootValue !== void 0)
           return rootValue;
       }
@@ -5805,17 +5805,17 @@ function createConfig$2(target = {}, parent) {
       const value = args[2];
       if (prop === "_n") {
         node = value;
-        if (target.rootConfig)
-          target.rootConfig._add(node);
+        if (target2.rootConfig)
+          target2.rootConfig._add(node);
         return true;
       }
       if (prop === "_rmn") {
-        if (target.rootConfig)
-          target.rootConfig._rm(node);
+        if (target2.rootConfig)
+          target2.rootConfig._rm(node);
         node = void 0;
         return true;
       }
-      if (!eq$1(target[prop], value, false)) {
+      if (!eq$1(target2[prop], value, false)) {
         const didSet = Reflect.set(...args);
         if (node) {
           node.emit(`config:${prop}`, value, false);
@@ -5934,10 +5934,10 @@ function useSteps() {
     }
     if (el) {
       var __tempEl__ = document.createElement("input");
-      var coords = getCoords$1(el);
+      var coords2 = getCoords$2(el);
       __tempEl__.style.position = "absolute";
-      __tempEl__.style.top = coords.top + 7 + "px";
-      __tempEl__.style.left = coords.left + "px";
+      __tempEl__.style.top = coords2.top + 7 + "px";
+      __tempEl__.style.left = coords2.left + "px";
       __tempEl__.style.height = 0;
       __tempEl__.style.opacity = 0;
       document.body.appendChild(__tempEl__);
@@ -6090,10 +6090,10 @@ function useSteps() {
   return { stepPlugin: stepPlugin2, steps: steps2, stepHistory: stepHistory2, stepQueue: stepQueue2, enabledSteps: enabledSteps2, defaultOrder: defaultOrder2, activeStep: activeStep2, firstStep: firstStep2, lastStep: lastStep2, setStep: setStep2, setStepQueue, setNextStep: setNextStep2, setPreviousStep: setPreviousStep2 };
 }
 let { prepopPlugin } = usePrepop();
-let { stepPlugin, steps, stepHistory, stepQueue, enabledSteps, defaultOrder, activeStep, firstStep, lastStep, setStep, setNextStep, setPreviousStep } = useSteps();
+let { stepPlugin, steps: steps$1, stepHistory, stepQueue, enabledSteps, defaultOrder, activeStep, firstStep, lastStep, setStep, setNextStep, setPreviousStep } = useSteps();
 const urlParams$2 = new URLSearchParams(window.location.search);
 const dataDefaults = {
-  steps,
+  steps: steps$1,
   activeStep,
   stepHistory,
   stepQueue,
@@ -6120,7 +6120,7 @@ const dataDefaults = {
     return setStep({ nextStep, validate: validate2, autoFocus, preStep });
   },
   stepIsValid: (stepName) => {
-    return steps[stepName].valid && steps[stepName].errorCount === 0;
+    return steps$1[stepName].valid && steps$1[stepName].errorCount === 0;
   },
   stepIsEnabled: (stepName) => {
     if (!enabledSteps().length) {
@@ -6884,8 +6884,8 @@ function createLedger() {
     count: (...args) => createCounter(n, ledger, ...args),
     init(node) {
       n = node;
-      node.on("message-added.deep", add(ledger, 1));
-      node.on("message-removed.deep", add(ledger, -1));
+      node.on("message-added.deep", add$1(ledger, 1));
+      node.on("message-removed.deep", add$1(ledger, -1));
     },
     merge: (child) => merge(n, ledger, child),
     settled(counterName) {
@@ -6938,7 +6938,7 @@ function count(counter, increment) {
   counter.node.emit(`count:${counter.name}`, counter.count, false);
   return counter;
 }
-function add(ledger, delta) {
+function add$1(ledger, delta) {
   return (e2) => {
     for (const name in ledger) {
       const counter = ledger[name];
@@ -7008,11 +7008,11 @@ function configChange(node, prop, value) {
 }
 function createConfig$1(options2 = {}) {
   const nodes = /* @__PURE__ */ new Set();
-  const target = __spreadValues(__spreadValues({}, options2), {
+  const target2 = __spreadValues(__spreadValues({}, options2), {
     _add: (node) => nodes.add(node),
     _rm: (node) => nodes.delete(node)
   });
-  const rootConfig = new Proxy(target, {
+  const rootConfig = new Proxy(target2, {
     set(t2, prop, value, r) {
       if (typeof prop === "string") {
         nodes.forEach((node) => configChange(node, prop, value));
@@ -7611,13 +7611,13 @@ function getRoot(n) {
   }
   return node;
 }
-function createConfig(target = {}, parent) {
+function createConfig(target2 = {}, parent) {
   let node = void 0;
-  return new Proxy(target, {
+  return new Proxy(target2, {
     get(...args) {
       const prop = args[1];
       if (prop === "_t")
-        return target;
+        return target2;
       const localValue = Reflect.get(...args);
       if (localValue !== void 0)
         return localValue;
@@ -7626,8 +7626,8 @@ function createConfig(target = {}, parent) {
         if (parentVal !== void 0)
           return parentVal;
       }
-      if (target.rootConfig && typeof prop === "string") {
-        const rootValue = target.rootConfig[prop];
+      if (target2.rootConfig && typeof prop === "string") {
+        const rootValue = target2.rootConfig[prop];
         if (rootValue !== void 0)
           return rootValue;
       }
@@ -7640,17 +7640,17 @@ function createConfig(target = {}, parent) {
       const value = args[2];
       if (prop === "_n") {
         node = value;
-        if (target.rootConfig)
-          target.rootConfig._add(node);
+        if (target2.rootConfig)
+          target2.rootConfig._add(node);
         return true;
       }
       if (prop === "_rmn") {
-        if (target.rootConfig)
-          target.rootConfig._rm(node);
+        if (target2.rootConfig)
+          target2.rootConfig._rm(node);
         node = void 0;
         return true;
       }
-      if (!eq(target[prop], value, false)) {
+      if (!eq(target2[prop], value, false)) {
         const didSet = Reflect.set(...args);
         if (node) {
           node.emit(`config:${prop}`, value, false);
@@ -7725,7 +7725,7 @@ function createProps(initial) {
         return node.config[prop];
       return void 0;
     },
-    set(target, property, originalValue, receiver) {
+    set(target2, property, originalValue, receiver) {
       if (property === "_n") {
         node = originalValue;
         return true;
@@ -7739,7 +7739,7 @@ function createProps(initial) {
         value: originalValue
       });
       if (!eq(props2[prop], value, false) || typeof value === "object") {
-        const didSet = Reflect.set(target, prop, value, receiver);
+        const didSet = Reflect.set(target2, prop, value, receiver);
         if (isEmitting) {
           node.emit("prop", { prop, value });
           if (typeof prop === "string")
@@ -8288,7 +8288,7 @@ function shouldSelect(valueA, valueB) {
     return eq(valueA, valueB);
   return false;
 }
-function options(node) {
+function options$1(node) {
   node.hook.prop((prop, next) => {
     if (prop.prop === "options") {
       if (typeof prop.value === "function") {
@@ -8923,8 +8923,8 @@ function deferChange(node, e2) {
   });
 }
 function selectInput(node, e2) {
-  const target = e2.target;
-  const value = target.hasAttribute("multiple") ? Array.from(target.selectedOptions).map((o) => optionValue(node.props.options, o.value)) : optionValue(node.props.options, target.value);
+  const target2 = e2.target;
+  const value = target2.hasAttribute("multiple") ? Array.from(target2.selectedOptions).map((o) => optionValue(node.props.options, o.value)) : optionValue(node.props.options, target2.value);
   node.input(value);
 }
 function applyPlaceholder(options2, placeholder) {
@@ -9083,7 +9083,7 @@ const checkbox = {
   family: "box",
   props: ["options", "onValue", "offValue", "optionsLoader"],
   features: [
-    options,
+    options$1,
     checkboxes,
     defaultIcon("decorator", "checkboxDecorator")
   ],
@@ -9158,7 +9158,7 @@ const radio = {
   props: ["options", "onValue", "offValue", "optionsLoader"],
   features: [
     disables,
-    options,
+    options$1,
     radios,
     defaultIcon("decorator", "radioDecorator")
   ],
@@ -9168,7 +9168,7 @@ const select = {
   schema: outer(wrapper(label("$label"), inner(icon("prefix"), prefix(), selectInput$1($if("$slots.default", () => "$slots.default", $if("$slots.option", optionSlot, option("$option.label")))), $if("$attrs.multiple !== undefined", () => "", icon("select")), suffix(), icon("suffix"))), help("$help"), messages$1(message$1("$message.value"))),
   type: "input",
   props: ["options", "placeholder", "optionsLoader"],
-  features: [options, select$1, defaultIcon("select", "select")],
+  features: [options$1, select$1, defaultIcon("select", "select")],
   schemaMemoKey: "cb119h43krg"
 };
 const textarea = {
@@ -10459,7 +10459,7 @@ const memo = {};
 const memoKeys = {};
 let instanceKey;
 const instanceScopes = /* @__PURE__ */ new WeakMap();
-const raw = "__raw__";
+const raw$1 = "__raw__";
 const isClassProp = /[a-zA-Z0-9\-][cC]lass$/;
 function getRef(token2, data) {
   const value = ref(null);
@@ -10507,9 +10507,9 @@ function get(nodeRefs, id) {
     nodeRefs[id] = ref(void 0);
   if (nodeRefs[id].value === void 0) {
     nodeRefs[id].value = null;
-    const root = getNode$1(id);
-    if (root)
-      nodeRefs[id].value = root.context;
+    const root2 = getNode$1(id);
+    if (root2)
+      nodeRefs[id].value = root2.context;
     watchRegistry(id, ({ payload: node }) => {
       nodeRefs[id].value = isNode(node) ? node.context : node;
     });
@@ -10568,7 +10568,7 @@ function parseSchema(library, schema, memoKey) {
         const value = unparsedAttrs[attr];
         let getValue2;
         const isStr = typeof value === "string";
-        if (attr.startsWith(raw)) {
+        if (attr.startsWith(raw$1)) {
           attr = attr.substring(7);
           getValue2 = () => value;
         } else if (isStr && value.startsWith("$") && value.length > 1 && !(value.startsWith("$reset") && isClassProp.test(attr))) {
@@ -11388,10 +11388,10 @@ const vueBindings = function vueBindings2(node) {
   const cachedClasses = reactive({});
   const classes = new Proxy(cachedClasses, {
     get(...args) {
-      const [target, property] = args;
+      const [target2, property] = args;
       let className = Reflect.get(...args);
       if (!className && typeof property === "string") {
-        if (!has(target, property) && !property.startsWith("__v")) {
+        if (!has(target2, property) && !property.startsWith("__v")) {
           const observedNode = createObserver(node);
           observedNode.watch((node2) => {
             const rootClasses = typeof node2.config.rootClasses === "function" ? node2.config.rootClasses(property, node2) : {};
@@ -11399,7 +11399,7 @@ const vueBindings = function vueBindings2(node) {
             const classesPropClasses = createClasses(property, node2, node2.props[`_${property}Class`]);
             const sectionPropClasses = createClasses(property, node2, node2.props[`${property}Class`]);
             className = generateClassList(node2, property, rootClasses, globalConfigClasses, classesPropClasses, sectionPropClasses);
-            target[property] = className !== null && className !== void 0 ? className : "";
+            target2[property] = className !== null && className !== void 0 ? className : "";
           });
         }
       }
@@ -11669,6 +11669,563 @@ defineComponent({
     };
   }
 });
+const parents = /* @__PURE__ */ new Set();
+const coords = /* @__PURE__ */ new WeakMap();
+const siblings = /* @__PURE__ */ new WeakMap();
+const animations = /* @__PURE__ */ new WeakMap();
+const intersections = /* @__PURE__ */ new WeakMap();
+const options = /* @__PURE__ */ new WeakMap();
+const debounces = /* @__PURE__ */ new WeakMap();
+const enabled = /* @__PURE__ */ new WeakSet();
+let root;
+const TGT = "__aa_tgt";
+const DEL = "__aa_del";
+const handleMutations = (mutations) => {
+  const elements = getElements(mutations);
+  if (elements) {
+    elements.forEach((el) => animate(el));
+  }
+};
+const handleResizes = (entries) => {
+  entries.forEach((entry) => {
+    if (entry.target === root)
+      updateAllPos();
+    if (coords.has(entry.target))
+      updatePos(entry.target);
+  });
+};
+function observePosition(el) {
+  const oldObserver = intersections.get(el);
+  oldObserver === null || oldObserver === void 0 ? void 0 : oldObserver.disconnect();
+  let rect = coords.get(el);
+  let invocations = 0;
+  const buffer = 5;
+  if (!rect) {
+    rect = getCoords$1(el);
+    coords.set(el, rect);
+  }
+  const { offsetWidth, offsetHeight } = root;
+  const rootMargins = [
+    rect.top - buffer,
+    offsetWidth - (rect.left + buffer + rect.width),
+    offsetHeight - (rect.top + buffer + rect.height),
+    rect.left - buffer
+  ];
+  const rootMargin = rootMargins.map((px) => `${-1 * Math.floor(px)}px`).join(" ");
+  const observer = new IntersectionObserver(() => {
+    ++invocations > 1 && updatePos(el);
+  }, {
+    root,
+    threshold: 1,
+    rootMargin
+  });
+  observer.observe(el);
+  intersections.set(el, observer);
+}
+function updatePos(el) {
+  clearTimeout(debounces.get(el));
+  const optionsOrPlugin = getOptions(el);
+  const delay = typeof optionsOrPlugin === "function" ? 500 : optionsOrPlugin.duration;
+  debounces.set(el, setTimeout(() => __async(this, null, function* () {
+    const currentAnimation = animations.get(el);
+    try {
+      yield currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.finished;
+      coords.set(el, getCoords$1(el));
+      observePosition(el);
+    } catch (e2) {
+    }
+  }), delay));
+}
+function updateAllPos() {
+  clearTimeout(debounces.get(root));
+  debounces.set(root, setTimeout(() => {
+    parents.forEach((parent) => forEach(parent, (el) => lowPriority(() => updatePos(el))));
+  }, 100));
+}
+function lowPriority(callback) {
+  if (typeof requestIdleCallback === "function") {
+    requestIdleCallback(() => callback());
+  } else {
+    requestAnimationFrame(() => callback());
+  }
+}
+let resize;
+if (typeof window !== "undefined") {
+  root = document.documentElement;
+  new MutationObserver(handleMutations);
+  resize = new ResizeObserver(handleResizes);
+  resize.observe(root);
+}
+function getElements(mutations) {
+  const observedNodes = mutations.reduce((nodes, mutation) => {
+    return [
+      ...nodes,
+      ...Array.from(mutation.addedNodes),
+      ...Array.from(mutation.removedNodes)
+    ];
+  }, []);
+  const onlyCommentNodesObserved = observedNodes.every((node) => node.nodeName === "#comment");
+  if (onlyCommentNodesObserved)
+    return false;
+  return mutations.reduce((elements, mutation) => {
+    if (elements === false)
+      return false;
+    if (mutation.target instanceof Element) {
+      target(mutation.target);
+      if (!elements.has(mutation.target)) {
+        elements.add(mutation.target);
+        for (let i2 = 0; i2 < mutation.target.children.length; i2++) {
+          const child = mutation.target.children.item(i2);
+          if (!child)
+            continue;
+          if (DEL in child)
+            return false;
+          target(mutation.target, child);
+          elements.add(child);
+        }
+      }
+      if (mutation.removedNodes.length) {
+        for (let i2 = 0; i2 < mutation.removedNodes.length; i2++) {
+          const child = mutation.removedNodes[i2];
+          if (DEL in child)
+            return false;
+          if (child instanceof Element) {
+            elements.add(child);
+            target(mutation.target, child);
+            siblings.set(child, [
+              mutation.previousSibling,
+              mutation.nextSibling
+            ]);
+          }
+        }
+      }
+    }
+    return elements;
+  }, /* @__PURE__ */ new Set());
+}
+function target(el, child) {
+  if (!child && !(TGT in el))
+    Object.defineProperty(el, TGT, { value: el });
+  else if (child && !(TGT in child))
+    Object.defineProperty(child, TGT, { value: el });
+}
+function animate(el) {
+  var _a;
+  const isMounted = el.isConnected;
+  const preExisting = coords.has(el);
+  if (isMounted && siblings.has(el))
+    siblings.delete(el);
+  if (animations.has(el)) {
+    (_a = animations.get(el)) === null || _a === void 0 ? void 0 : _a.cancel();
+  }
+  if (preExisting && isMounted) {
+    remain(el);
+  } else if (preExisting && !isMounted) {
+    remove(el);
+  } else {
+    add(el);
+  }
+}
+function raw(str) {
+  return Number(str.replace(/[^0-9.\-]/g, ""));
+}
+function getCoords$1(el) {
+  const rect = el.getBoundingClientRect();
+  return {
+    top: rect.top + window.scrollY,
+    left: rect.left + window.scrollX,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function getTransitionSizes(el, oldCoords, newCoords) {
+  let widthFrom = oldCoords.width;
+  let heightFrom = oldCoords.height;
+  let widthTo = newCoords.width;
+  let heightTo = newCoords.height;
+  const styles = getComputedStyle(el);
+  const sizing = styles.getPropertyValue("box-sizing");
+  if (sizing === "content-box") {
+    const paddingY = raw(styles.paddingTop) + raw(styles.paddingBottom) + raw(styles.borderTopWidth) + raw(styles.borderBottomWidth);
+    const paddingX = raw(styles.paddingLeft) + raw(styles.paddingRight) + raw(styles.borderRightWidth) + raw(styles.borderLeftWidth);
+    widthFrom -= paddingX;
+    widthTo -= paddingX;
+    heightFrom -= paddingY;
+    heightTo -= paddingY;
+  }
+  return [widthFrom, widthTo, heightFrom, heightTo].map(Math.round);
+}
+function getOptions(el) {
+  return TGT in el && options.has(el[TGT]) ? options.get(el[TGT]) : { duration: 250, easing: "ease-in-out" };
+}
+function getTarget(el) {
+  if (TGT in el)
+    return el[TGT];
+  return void 0;
+}
+function isEnabled(el) {
+  const target2 = getTarget(el);
+  return target2 ? enabled.has(target2) : false;
+}
+function forEach(parent, ...callbacks) {
+  callbacks.forEach((callback) => callback(parent, options.has(parent)));
+  for (let i2 = 0; i2 < parent.children.length; i2++) {
+    const child = parent.children.item(i2);
+    if (child) {
+      callbacks.forEach((callback) => callback(child, options.has(child)));
+    }
+  }
+}
+function remain(el) {
+  const oldCoords = coords.get(el);
+  const newCoords = getCoords$1(el);
+  if (!isEnabled(el))
+    return coords.set(el, newCoords);
+  let animation;
+  if (!oldCoords)
+    return;
+  const pluginOrOptions = getOptions(el);
+  if (typeof pluginOrOptions !== "function") {
+    const deltaX = oldCoords.left - newCoords.left;
+    const deltaY = oldCoords.top - newCoords.top;
+    const [widthFrom, widthTo, heightFrom, heightTo] = getTransitionSizes(el, oldCoords, newCoords);
+    const start = {
+      transform: `translate(${deltaX}px, ${deltaY}px)`
+    };
+    const end = {
+      transform: `translate(0, 0)`
+    };
+    if (widthFrom !== widthTo) {
+      start.width = `${widthFrom}px`;
+      end.width = `${widthTo}px`;
+    }
+    if (heightFrom !== heightTo) {
+      start.height = `${heightFrom}px`;
+      end.height = `${heightTo}px`;
+    }
+    animation = el.animate([start, end], {
+      duration: pluginOrOptions.duration,
+      easing: pluginOrOptions.easing
+    });
+  } else {
+    animation = new Animation(pluginOrOptions(el, "remain", oldCoords, newCoords));
+    animation.play();
+  }
+  animations.set(el, animation);
+  coords.set(el, newCoords);
+  animation.addEventListener("finish", updatePos.bind(null, el));
+}
+function add(el) {
+  const newCoords = getCoords$1(el);
+  coords.set(el, newCoords);
+  const pluginOrOptions = getOptions(el);
+  if (!isEnabled(el))
+    return;
+  let animation;
+  if (typeof pluginOrOptions !== "function") {
+    animation = el.animate([
+      { transform: "scale(.98)", opacity: 0 },
+      { transform: "scale(0.98)", opacity: 0, offset: 0.5 },
+      { transform: "scale(1)", opacity: 1 }
+    ], {
+      duration: pluginOrOptions.duration * 1.5,
+      easing: "ease-in"
+    });
+  } else {
+    animation = new Animation(pluginOrOptions(el, "add", newCoords));
+    animation.play();
+  }
+  animations.set(el, animation);
+  animation.addEventListener("finish", updatePos.bind(null, el));
+}
+function remove(el) {
+  var _a;
+  if (!siblings.has(el) || !coords.has(el))
+    return;
+  const [prev, next] = siblings.get(el);
+  Object.defineProperty(el, DEL, { value: true });
+  if (next && next.parentNode && next.parentNode instanceof Element) {
+    next.parentNode.insertBefore(el, next);
+  } else if (prev && prev.parentNode) {
+    prev.parentNode.appendChild(el);
+  } else {
+    (_a = getTarget(el)) === null || _a === void 0 ? void 0 : _a.appendChild(el);
+  }
+  function cleanUp() {
+    var _a2;
+    el.remove();
+    coords.delete(el);
+    siblings.delete(el);
+    animations.delete(el);
+    (_a2 = intersections.get(el)) === null || _a2 === void 0 ? void 0 : _a2.disconnect();
+  }
+  if (!isEnabled(el))
+    return cleanUp();
+  const [top, left, width, height] = deletePosition(el);
+  const optionsOrPlugin = getOptions(el);
+  const oldCoords = coords.get(el);
+  let animation;
+  Object.assign(el.style, {
+    position: "absolute",
+    top: `${top}px`,
+    left: `${left}px`,
+    width: `${width}px`,
+    height: `${height}px`,
+    margin: 0,
+    pointerEvents: "none",
+    transformOrigin: "center",
+    zIndex: 100
+  });
+  if (typeof optionsOrPlugin !== "function") {
+    animation = el.animate([
+      {
+        transform: "scale(1)",
+        opacity: 1
+      },
+      {
+        transform: "scale(.98)",
+        opacity: 0
+      }
+    ], { duration: optionsOrPlugin.duration, easing: "ease-out" });
+  } else {
+    animation = new Animation(optionsOrPlugin(el, "remove", oldCoords));
+    animation.play();
+  }
+  animations.set(el, animation);
+  animation.addEventListener("finish", cleanUp);
+}
+function deletePosition(el) {
+  const oldCoords = coords.get(el);
+  const [width, , height] = getTransitionSizes(el, oldCoords, getCoords$1(el));
+  let offsetParent = el.parentElement;
+  while (offsetParent && (getComputedStyle(offsetParent).position === "static" || offsetParent instanceof HTMLBodyElement)) {
+    offsetParent = offsetParent.parentElement;
+  }
+  if (!offsetParent)
+    offsetParent = document.body;
+  const parentStyles = getComputedStyle(offsetParent);
+  const parentCoords = coords.get(offsetParent) || getCoords$1(offsetParent);
+  const top = Math.round(oldCoords.top - parentCoords.top) - raw(parentStyles.borderTopWidth);
+  const left = Math.round(oldCoords.left - parentCoords.left) - raw(parentStyles.borderLeftWidth);
+  return [top, left, width, height];
+}
+const badge = createSection("badge", () => ({
+  $el: "span",
+  attrs: {
+    role: "presentation"
+  }
+}));
+const stepActions = createSection("stepActions", () => ({
+  $el: "div"
+}));
+const stepInner = createSection("stepInner", "div");
+const stepNext = createSection("stepNext", () => ({
+  $el: "div",
+  if: "$isLastStep === false",
+  children: [
+    {
+      $cmp: "FormKit",
+      bind: "$nextAttrs",
+      props: {
+        type: "button",
+        label: {
+          if: "$nextLabel",
+          then: "$nextLabel",
+          else: "$ui.next.value"
+        },
+        "data-next": "$isLastStep === false",
+        onClick: "$handlers.next"
+      }
+    }
+  ]
+}));
+const stepOuter = createSection("stepOuter", () => ({
+  $el: "div",
+  attrs: {
+    key: "$id",
+    "data-type": "step",
+    "data-disabled": "$disabled || undefined",
+    "data-complete": "$state.complete || undefined",
+    "data-invalid": "$state.valid === false && $state.validationVisible || undefined",
+    "data-errors": "$state.errors || undefined",
+    "data-submitted": "$state.submitted || undefined",
+    id: "$id",
+    role: "tabpanel",
+    "aria-labelledby": '$node.parent.props.id + "_tab_" + $stepIndex',
+    class: "$classes.step",
+    hidden: "$isActiveStep === false || undefined"
+  }
+}));
+const stepPrevious = createSection("stepPrevious", () => ({
+  $el: "div",
+  if: "$isFirstStep === false",
+  children: [
+    {
+      $cmp: "FormKit",
+      bind: "$previousAttrs",
+      props: {
+        type: "button",
+        label: {
+          if: "$previousLabel",
+          then: "$previousLabel",
+          else: "$ui.prev.value"
+        },
+        "data-prev": "$isFirstStep === false",
+        onClick: "$handlers.previous"
+      }
+    }
+  ]
+}));
+const steps = createSection("steps", () => ({
+  $el: "div"
+}));
+const stepIcon = (sectionKey, el) => {
+  return createSection(`${sectionKey}Icon`, () => {
+    const rawIconProp = `_raw${sectionKey.charAt(0).toUpperCase()}${sectionKey.slice(1)}Icon`;
+    return {
+      if: `$step.${sectionKey}Icon && $step.${rawIconProp}`,
+      then: {
+        $el: `${el ? el : "span"}`,
+        attrs: {
+          class: `$classes.${sectionKey}Icon + " formkit-icon"`,
+          innerHTML: `$step.${rawIconProp}`,
+          role: "presentation",
+          onClick: `$handlers.iconClick(${sectionKey})`
+        }
+      },
+      else: {
+        if: `$${sectionKey}Icon && $${rawIconProp}`,
+        then: {
+          $el: `${el ? el : "span"}`,
+          attrs: {
+            class: `$classes.${sectionKey}Icon + " formkit-icon"`,
+            innerHTML: `$${rawIconProp}`,
+            role: "presentation",
+            onClick: `$handlers.iconClick(${sectionKey})`
+          }
+        }
+      }
+    };
+  })();
+};
+const tab = createSection("tab", () => ({
+  $el: "button",
+  for: ["step", "index", "$steps"],
+  attrs: {
+    type: "button",
+    onClick: "$step.makeActive",
+    "data-active": "$step.isActiveStep",
+    "data-valid": "$step.isValid",
+    "data-visited": "$step.hasBeenVisited",
+    role: "tab",
+    id: '$id + "_tab_" + $index',
+    "aria-selected": "$step.isActiveStep || false",
+    "aria-controls": "$step.id",
+    tabindex: {
+      if: "$step.isActiveStep",
+      then: "0",
+      else: "-1"
+    },
+    style: {
+      if: "$step.ordered",
+      then: "",
+      else: "display: none"
+    }
+  }
+}));
+const tabLabel = createSection("tabLabel", () => ({
+  $el: "span"
+}));
+const tabs = createSection("tabs", () => ({
+  $el: "div",
+  attrs: {
+    role: "tablist"
+  }
+}));
+const multiStepOuter = createSection("multiStepOuter", () => ({
+  $el: "div",
+  attrs: {
+    key: "$id",
+    id: "$id",
+    class: "$classes.outer",
+    "data-family": "$family || undefined",
+    "data-type": "$type",
+    "data-multiple": '$attrs.multiple || ($type != "select" && $options != undefined) || undefined',
+    "data-disabled": "$disabled || undefined",
+    "data-complete": "$state.complete || undefined",
+    "data-invalid": "$state.valid === false && $state.validationVisible || undefined",
+    "data-errors": "$state.errors || undefined",
+    "data-submitted": "$state.submitted || undefined"
+  }
+}));
+({
+  schema: multiStepOuter($extend(wrapper(tabs(tab($if('$tabStyle === "tab" || ($tabStyle === "progress" && $hideProgressLabels === false)', tabLabel("$step.stepName")), $if("($step.totalErrorCount > 0) && $step.showStepErrors", badge("$step.totalErrorCount")), $if("$step.isValid && $step.hasBeenVisited", badge(stepIcon("validStep"))))), steps("$slots.default")), {
+    attrs: {
+      "data-tab-style": "$tabStyle",
+      "data-hide-labels": "$hideProgressLabels"
+    }
+  })),
+  type: "group",
+  family: "multi-step",
+  props: [
+    "allowIncomplete",
+    "hideProgressLabels",
+    "tabStyle",
+    "beforeStepChange",
+    "validStepIcon"
+  ],
+  features: [defaultIcon("validStep", "check")]
+});
+({
+  schema: stepOuter(stepInner("$slots.default"), stepActions(stepPrevious(), stepNext())),
+  type: "group",
+  family: "",
+  props: [
+    "previousLabel",
+    "nextLabel",
+    "beforeStepChange",
+    "previousAttrs",
+    "nextAttrs",
+    "validStepIcon"
+  ],
+  features: [localize$2("next"), localize$2("prev")]
+});
+function createLocalStoragePlugin(LocalStorageOptions) {
+  const localStoragePlugin = (node) => {
+    if (node.props.type !== "form")
+      return;
+    node.addProps(["useLocalStorage"]);
+    node.on("created", () => {
+      var _a, _b;
+      const useLocalStorage = undefine(node.props.useLocalStorage);
+      if (!useLocalStorage)
+        return;
+      const prefix2 = (_a = LocalStorageOptions === null || LocalStorageOptions === void 0 ? void 0 : LocalStorageOptions.prefix) !== null && _a !== void 0 ? _a : "formkit";
+      const maxAge = (_b = LocalStorageOptions === null || LocalStorageOptions === void 0 ? void 0 : LocalStorageOptions.maxAge) !== null && _b !== void 0 ? _b : 36e5;
+      const key = `${prefix2}-${node.name}`;
+      const value = localStorage.getItem(key);
+      if (value) {
+        const localStorageValue = JSON.parse(value);
+        if (localStorageValue.maxAge > Date.now()) {
+          node.input(localStorageValue.data);
+        } else {
+          localStorage.removeItem(key);
+        }
+      }
+      node.on("commit", ({ payload }) => {
+        localStorage.setItem(key, JSON.stringify({
+          maxAge: Date.now() + maxAge,
+          data: payload
+        }));
+      });
+      node.hook.submit((payload, next) => {
+        localStorage.removeItem(key);
+        return next(payload);
+      });
+    });
+  };
+  return localStoragePlugin;
+}
 var createPlugin$2 = {};
 var createPlugin$1 = {};
 (function(exports) {
@@ -13911,16 +14468,16 @@ function cleanEscapedString$1(input2) {
   }
   return matched[1].replace(doubleQuoteRegExp$1, "'");
 }
-function assign(target, object) {
-  if (target == null) {
+function assign(target2, object) {
+  if (target2 == null) {
     throw new TypeError("assign requires that input parameter not be null or undefined");
   }
   for (var property in object) {
     if (Object.prototype.hasOwnProperty.call(object, property)) {
-      target[property] = object[property];
+      target2[property] = object[property];
     }
   }
-  return target;
+  return target2;
 }
 function getDaysInMonth(dirtyDate) {
   requiredArgs(1, arguments);
@@ -14034,14 +14591,14 @@ function _classCallCheck$w(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$w(target, props2) {
+function _defineProperties$w(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$w(Constructor, protoProps, staticProps) {
@@ -14135,14 +14692,14 @@ function _classCallCheck$v(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$v(target, props2) {
+function _defineProperties$v(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$v(Constructor, protoProps, staticProps) {
@@ -14194,14 +14751,14 @@ function _classCallCheck$u(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$u(target, props2) {
+function _defineProperties$u(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$u(Constructor, protoProps, staticProps) {
@@ -14482,14 +15039,14 @@ function _classCallCheck$t(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$t(target, props2) {
+function _defineProperties$t(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$t(Constructor, protoProps, staticProps) {
@@ -14643,14 +15200,14 @@ function _classCallCheck$s(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$s(target, props2) {
+function _defineProperties$s(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$s(Constructor, protoProps, staticProps) {
@@ -14804,14 +15361,14 @@ function _classCallCheck$r(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$r(target, props2) {
+function _defineProperties$r(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$r(Constructor, protoProps, staticProps) {
@@ -14941,14 +15498,14 @@ function _classCallCheck$q(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$q(target, props2) {
+function _defineProperties$q(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$q(Constructor, protoProps, staticProps) {
@@ -15077,14 +15634,14 @@ function _classCallCheck$p(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$p(target, props2) {
+function _defineProperties$p(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$p(Constructor, protoProps, staticProps) {
@@ -15248,14 +15805,14 @@ function _classCallCheck$o(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$o(target, props2) {
+function _defineProperties$o(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$o(Constructor, protoProps, staticProps) {
@@ -15419,14 +15976,14 @@ function _classCallCheck$n(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$n(target, props2) {
+function _defineProperties$n(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$n(Constructor, protoProps, staticProps) {
@@ -15594,14 +16151,14 @@ function _classCallCheck$m(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$m(target, props2) {
+function _defineProperties$m(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$m(Constructor, protoProps, staticProps) {
@@ -15777,14 +16334,14 @@ function _classCallCheck$l(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$l(target, props2) {
+function _defineProperties$l(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$l(Constructor, protoProps, staticProps) {
@@ -15930,14 +16487,14 @@ function _classCallCheck$k(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$k(target, props2) {
+function _defineProperties$k(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$k(Constructor, protoProps, staticProps) {
@@ -16075,14 +16632,14 @@ function _classCallCheck$j(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$j(target, props2) {
+function _defineProperties$j(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$j(Constructor, protoProps, staticProps) {
@@ -16232,14 +16789,14 @@ function _classCallCheck$i(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$i(target, props2) {
+function _defineProperties$i(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$i(Constructor, protoProps, staticProps) {
@@ -16404,14 +16961,14 @@ function _classCallCheck$h(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$h(target, props2) {
+function _defineProperties$h(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$h(Constructor, protoProps, staticProps) {
@@ -16584,14 +17141,14 @@ function _classCallCheck$g(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$g(target, props2) {
+function _defineProperties$g(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$g(Constructor, protoProps, staticProps) {
@@ -16773,14 +17330,14 @@ function _classCallCheck$f(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$f(target, props2) {
+function _defineProperties$f(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$f(Constructor, protoProps, staticProps) {
@@ -16977,14 +17534,14 @@ function _classCallCheck$e(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$e(target, props2) {
+function _defineProperties$e(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$e(Constructor, protoProps, staticProps) {
@@ -17168,14 +17725,14 @@ function _classCallCheck$d(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$d(target, props2) {
+function _defineProperties$d(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$d(Constructor, protoProps, staticProps) {
@@ -17328,14 +17885,14 @@ function _classCallCheck$c(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$c(target, props2) {
+function _defineProperties$c(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$c(Constructor, protoProps, staticProps) {
@@ -17488,14 +18045,14 @@ function _classCallCheck$b(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$b(target, props2) {
+function _defineProperties$b(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$b(Constructor, protoProps, staticProps) {
@@ -17648,14 +18205,14 @@ function _classCallCheck$a(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$a(target, props2) {
+function _defineProperties$a(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$a(Constructor, protoProps, staticProps) {
@@ -17801,14 +18358,14 @@ function _classCallCheck$9(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$9(target, props2) {
+function _defineProperties$9(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$9(Constructor, protoProps, staticProps) {
@@ -17947,14 +18504,14 @@ function _classCallCheck$8(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$8(target, props2) {
+function _defineProperties$8(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$8(Constructor, protoProps, staticProps) {
@@ -18098,14 +18655,14 @@ function _classCallCheck$7(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$7(target, props2) {
+function _defineProperties$7(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$7(Constructor, protoProps, staticProps) {
@@ -18245,14 +18802,14 @@ function _classCallCheck$6(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$6(target, props2) {
+function _defineProperties$6(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$6(Constructor, protoProps, staticProps) {
@@ -18391,14 +18948,14 @@ function _classCallCheck$5(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$5(target, props2) {
+function _defineProperties$5(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$5(Constructor, protoProps, staticProps) {
@@ -18537,14 +19094,14 @@ function _classCallCheck$4(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$4(target, props2) {
+function _defineProperties$4(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$4(Constructor, protoProps, staticProps) {
@@ -18672,14 +19229,14 @@ function _classCallCheck$3(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$3(target, props2) {
+function _defineProperties$3(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$3(Constructor, protoProps, staticProps) {
@@ -18818,14 +19375,14 @@ function _classCallCheck$2(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$2(target, props2) {
+function _defineProperties$2(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$2(Constructor, protoProps, staticProps) {
@@ -18964,14 +19521,14 @@ function _classCallCheck$1(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties$1(target, props2) {
+function _defineProperties$1(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass$1(Constructor, protoProps, staticProps) {
@@ -19097,14 +19654,14 @@ function _classCallCheck(instance, Constructor) {
     throw new TypeError("Cannot call a class as a function");
   }
 }
-function _defineProperties(target, props2) {
+function _defineProperties(target2, props2) {
   for (var i2 = 0; i2 < props2.length; i2++) {
     var descriptor = props2[i2];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor)
       descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+    Object.defineProperty(target2, descriptor.key, descriptor);
   }
 }
 function _createClass(Constructor, protoProps, staticProps) {
@@ -19821,12 +20378,12 @@ var script$4 = defineComponent({
   setup(props2, { emit: emit2 }) {
     const from = computed(() => startOfDecade(props2.pageDate));
     const to = computed(() => endOfDecade(props2.pageDate));
-    const isEnabled = (target, lower, upper) => {
+    const isEnabled2 = (target2, lower, upper) => {
       if (!lower && !upper)
         return true;
-      if (lower && getYear(target) < getYear(lower))
+      if (lower && getYear(target2) < getYear(lower))
         return false;
-      if (upper && getYear(target) > getYear(upper))
+      if (upper && getYear(target2) > getYear(upper))
         return false;
       return true;
     };
@@ -19838,7 +20395,7 @@ var script$4 = defineComponent({
       key: String(getYear(value)),
       display: getYear(value),
       selected: props2.selected && getYear(value) === getYear(props2.selected),
-      disabled: !isEnabled(value, props2.lowerLimit, props2.upperLimit)
+      disabled: !isEnabled2(value, props2.lowerLimit, props2.upperLimit)
     })));
     const heading = computed(() => {
       const start = getYear(from.value);
@@ -19920,12 +20477,12 @@ var script$3 = defineComponent({
     const format2 = computed(() => formatWithOptions({
       locale: props2.locale
     })(props2.format));
-    const isEnabled = (target, lower, upper) => {
+    const isEnabled2 = (target2, lower, upper) => {
       if (!lower && !upper)
         return true;
-      if (lower && isBefore(target, startOfMonth(lower)))
+      if (lower && isBefore(target2, startOfMonth(lower)))
         return false;
-      if (upper && isAfter(target, endOfMonth(upper)))
+      if (upper && isAfter(target2, endOfMonth(upper)))
         return false;
       return true;
     };
@@ -19937,7 +20494,7 @@ var script$3 = defineComponent({
       display: format2.value(value),
       key: format2.value(value),
       selected: props2.selected && isSameMonth(props2.selected, value),
-      disabled: !isEnabled(value, props2.lowerLimit, props2.upperLimit)
+      disabled: !isEnabled2(value, props2.lowerLimit, props2.upperLimit)
     })));
     const heading = computed(() => getYear(from.value));
     const leftDisabled = computed(() => props2.lowerLimit && (isSameYear(props2.lowerLimit, props2.pageDate) || isBefore(props2.pageDate, props2.lowerLimit)));
@@ -20057,17 +20614,17 @@ var script$2 = defineComponent({
         weekStartsOn: props2.weekStartsOn
       })).map(dayFormat);
     });
-    const isEnabled = (target, lower, upper, disabledDates) => {
+    const isEnabled2 = (target2, lower, upper, disabledDates) => {
       var _a, _b;
-      if ((_a = disabledDates === null || disabledDates === void 0 ? void 0 : disabledDates.dates) === null || _a === void 0 ? void 0 : _a.some((date3) => isSameDay(target, date3)))
+      if ((_a = disabledDates === null || disabledDates === void 0 ? void 0 : disabledDates.dates) === null || _a === void 0 ? void 0 : _a.some((date3) => isSameDay(target2, date3)))
         return false;
-      if ((_b = disabledDates === null || disabledDates === void 0 ? void 0 : disabledDates.predicate) === null || _b === void 0 ? void 0 : _b.call(disabledDates, target))
+      if ((_b = disabledDates === null || disabledDates === void 0 ? void 0 : disabledDates.predicate) === null || _b === void 0 ? void 0 : _b.call(disabledDates, target2))
         return false;
       if (!lower && !upper)
         return true;
-      if (lower && isBefore(target, startOfDay(lower)))
+      if (lower && isBefore(target2, startOfDay(lower)))
         return false;
-      if (upper && isAfter(target, endOfDay(upper)))
+      if (upper && isAfter(target2, endOfDay(upper)))
         return false;
       return true;
     };
@@ -20077,7 +20634,7 @@ var script$2 = defineComponent({
         value,
         display: dayFormat(value),
         selected: props2.selected && isSameDay(props2.selected, value),
-        disabled: !isWithinInterval(value, currentMonth.value) || !isEnabled(value, props2.lowerLimit, props2.upperLimit, props2.disabledDates),
+        disabled: !isWithinInterval(value, currentMonth.value) || !isEnabled2(value, props2.lowerLimit, props2.upperLimit, props2.disabledDates),
         key: format2.value("yyyy-MM-dd", value)
       }));
     });
@@ -20220,12 +20777,12 @@ var script$1 = defineComponent({
         nextTick(scroll);
       }
     });
-    const isEnabled = (target) => {
+    const isEnabled2 = (target2) => {
       var _a, _b, _c, _d;
-      if ((_b = (_a = props2.disabledTime) === null || _a === void 0 ? void 0 : _a.dates) === null || _b === void 0 ? void 0 : _b.some((date3) => isSameHour(target, date3) && isSameMinute(target, date3))) {
+      if ((_b = (_a = props2.disabledTime) === null || _a === void 0 ? void 0 : _a.dates) === null || _b === void 0 ? void 0 : _b.some((date3) => isSameHour(target2, date3) && isSameMinute(target2, date3))) {
         return false;
       }
-      if ((_d = (_c = props2.disabledTime) === null || _c === void 0 ? void 0 : _c.predicate) === null || _d === void 0 ? void 0 : _d.call(_c, target))
+      if ((_d = (_c = props2.disabledTime) === null || _c === void 0 ? void 0 : _c.predicate) === null || _d === void 0 ? void 0 : _d.call(_c, target2))
         return false;
       return true;
     };
@@ -20239,7 +20796,7 @@ var script$1 = defineComponent({
       minutesList,
       padStartZero,
       selectMinutes,
-      isEnabled,
+      isEnabled: isEnabled2,
       scroll
     };
   }
@@ -20666,14 +21223,6 @@ const init = () => {
       data.fireStepEvent = data.fireStepEvent || fireStepEvent;
       data.handleRedirect = data.handleRedirect || handleRedirect;
       data.scrollAnchor = data.scrollAnchor || scrollAnchor;
-      data.inList = (list2, item) => {
-        if (!list2 || !item) {
-          console.log("inList blank", list2, item);
-          return false;
-        }
-        console.log("inList", list2, item, list2.includes(item));
-        return list2.includes(item);
-      };
       data.getVal = (formNode, key) => {
         if (!formNode || !key) {
           return;
@@ -20718,7 +21267,13 @@ const init = () => {
           },
           config: {
             classes
-          }
+          },
+          plugins: [
+            createLocalStoragePlugin({
+              prefix: "formkit",
+              maxAge: 24 * 36e5
+            })
+          ]
         })
       );
       app.mount("#" + form2.target);