@fkui/vue 6.0.0 → 6.0.1

package/dist/esm/index.esm.js

@@ -35,11 +35,7 @@ const _sfc_main$1b = /* @__PURE__ */ defineComponent({
     };
   }
 });
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-var es_array_push = {};
+var es_iterator_constructor = {};
 var globalThis_1;
 var hasRequiredGlobalThis;
 function requireGlobalThis() {
@@ -178,13 +174,13 @@ function requireIndexedObject() {
   hasRequiredIndexedObject = 1;
   var uncurryThis = requireFunctionUncurryThis();
   var fails2 = requireFails();
-  var classof = requireClassofRaw();
+  var classof2 = requireClassofRaw();
   var $Object = Object;
   var split = uncurryThis("".split);
   indexedObject = fails2(function() {
     return !$Object("z").propertyIsEnumerable(0);
   }) ? function(it) {
-    return classof(it) === "String" ? split(it, "") : $Object(it);
+    return classof2(it) === "String" ? split(it, "") : $Object(it);
   } : $Object;
   return indexedObject;
 }
@@ -1217,14 +1213,579 @@ function require_export() {
   };
   return _export;
 }
+var anInstance;
+var hasRequiredAnInstance;
+function requireAnInstance() {
+  if (hasRequiredAnInstance) return anInstance;
+  hasRequiredAnInstance = 1;
+  var isPrototypeOf = requireObjectIsPrototypeOf();
+  var $TypeError = TypeError;
+  anInstance = function(it, Prototype) {
+    if (isPrototypeOf(Prototype, it)) return it;
+    throw new $TypeError("Incorrect invocation");
+  };
+  return anInstance;
+}
+var correctPrototypeGetter;
+var hasRequiredCorrectPrototypeGetter;
+function requireCorrectPrototypeGetter() {
+  if (hasRequiredCorrectPrototypeGetter) return correctPrototypeGetter;
+  hasRequiredCorrectPrototypeGetter = 1;
+  var fails2 = requireFails();
+  correctPrototypeGetter = !fails2(function() {
+    function F() {
+    }
+    F.prototype.constructor = null;
+    return Object.getPrototypeOf(new F()) !== F.prototype;
+  });
+  return correctPrototypeGetter;
+}
+var objectGetPrototypeOf;
+var hasRequiredObjectGetPrototypeOf;
+function requireObjectGetPrototypeOf() {
+  if (hasRequiredObjectGetPrototypeOf) return objectGetPrototypeOf;
+  hasRequiredObjectGetPrototypeOf = 1;
+  var hasOwn = requireHasOwnProperty();
+  var isCallable2 = requireIsCallable();
+  var toObject2 = requireToObject();
+  var sharedKey2 = requireSharedKey();
+  var CORRECT_PROTOTYPE_GETTER = requireCorrectPrototypeGetter();
+  var IE_PROTO = sharedKey2("IE_PROTO");
+  var $Object = Object;
+  var ObjectPrototype = $Object.prototype;
+  objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function(O) {
+    var object = toObject2(O);
+    if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
+    var constructor = object.constructor;
+    if (isCallable2(constructor) && object instanceof constructor) {
+      return constructor.prototype;
+    }
+    return object instanceof $Object ? ObjectPrototype : null;
+  };
+  return objectGetPrototypeOf;
+}
+var defineBuiltInAccessor;
+var hasRequiredDefineBuiltInAccessor;
+function requireDefineBuiltInAccessor() {
+  if (hasRequiredDefineBuiltInAccessor) return defineBuiltInAccessor;
+  hasRequiredDefineBuiltInAccessor = 1;
+  var makeBuiltIn2 = requireMakeBuiltIn();
+  var defineProperty = requireObjectDefineProperty();
+  defineBuiltInAccessor = function(target, name, descriptor) {
+    if (descriptor.get) makeBuiltIn2(descriptor.get, name, {
+      getter: true
+    });
+    if (descriptor.set) makeBuiltIn2(descriptor.set, name, {
+      setter: true
+    });
+    return defineProperty.f(target, name, descriptor);
+  };
+  return defineBuiltInAccessor;
+}
+var createProperty;
+var hasRequiredCreateProperty;
+function requireCreateProperty() {
+  if (hasRequiredCreateProperty) return createProperty;
+  hasRequiredCreateProperty = 1;
+  var DESCRIPTORS = requireDescriptors();
+  var definePropertyModule = requireObjectDefineProperty();
+  var createPropertyDescriptor2 = requireCreatePropertyDescriptor();
+  createProperty = function(object, key, value) {
+    if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor2(0, value));
+    else object[key] = value;
+  };
+  return createProperty;
+}
+var objectDefineProperties = {};
+var objectKeys;
+var hasRequiredObjectKeys;
+function requireObjectKeys() {
+  if (hasRequiredObjectKeys) return objectKeys;
+  hasRequiredObjectKeys = 1;
+  var internalObjectKeys = requireObjectKeysInternal();
+  var enumBugKeys2 = requireEnumBugKeys();
+  objectKeys = Object.keys || function keys(O) {
+    return internalObjectKeys(O, enumBugKeys2);
+  };
+  return objectKeys;
+}
+var hasRequiredObjectDefineProperties;
+function requireObjectDefineProperties() {
+  if (hasRequiredObjectDefineProperties) return objectDefineProperties;
+  hasRequiredObjectDefineProperties = 1;
+  var DESCRIPTORS = requireDescriptors();
+  var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
+  var definePropertyModule = requireObjectDefineProperty();
+  var anObject2 = requireAnObject();
+  var toIndexedObject2 = requireToIndexedObject();
+  var objectKeys2 = requireObjectKeys();
+  objectDefineProperties.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
+    anObject2(O);
+    var props = toIndexedObject2(Properties);
+    var keys = objectKeys2(Properties);
+    var length = keys.length;
+    var index = 0;
+    var key;
+    while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
+    return O;
+  };
+  return objectDefineProperties;
+}
+var html;
+var hasRequiredHtml;
+function requireHtml() {
+  if (hasRequiredHtml) return html;
+  hasRequiredHtml = 1;
+  var getBuiltIn2 = requireGetBuiltIn();
+  html = getBuiltIn2("document", "documentElement");
+  return html;
+}
+var objectCreate;
+var hasRequiredObjectCreate;
+function requireObjectCreate() {
+  if (hasRequiredObjectCreate) return objectCreate;
+  hasRequiredObjectCreate = 1;
+  var anObject2 = requireAnObject();
+  var definePropertiesModule = requireObjectDefineProperties();
+  var enumBugKeys2 = requireEnumBugKeys();
+  var hiddenKeys2 = requireHiddenKeys();
+  var html2 = requireHtml();
+  var documentCreateElement2 = requireDocumentCreateElement();
+  var sharedKey2 = requireSharedKey();
+  var GT = ">";
+  var LT = "<";
+  var PROTOTYPE = "prototype";
+  var SCRIPT = "script";
+  var IE_PROTO = sharedKey2("IE_PROTO");
+  var EmptyConstructor = function() {
+  };
+  var scriptTag = function(content) {
+    return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT;
+  };
+  var NullProtoObjectViaActiveX = function(activeXDocument2) {
+    activeXDocument2.write(scriptTag(""));
+    activeXDocument2.close();
+    var temp = activeXDocument2.parentWindow.Object;
+    activeXDocument2 = null;
+    return temp;
+  };
+  var NullProtoObjectViaIFrame = function() {
+    var iframe = documentCreateElement2("iframe");
+    var JS = "java" + SCRIPT + ":";
+    var iframeDocument;
+    iframe.style.display = "none";
+    html2.appendChild(iframe);
+    iframe.src = String(JS);
+    iframeDocument = iframe.contentWindow.document;
+    iframeDocument.open();
+    iframeDocument.write(scriptTag("document.F=Object"));
+    iframeDocument.close();
+    return iframeDocument.F;
+  };
+  var activeXDocument;
+  var NullProtoObject = function() {
+    try {
+      activeXDocument = new ActiveXObject("htmlfile");
+    } catch (error) {
+    }
+    NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument);
+    var length = enumBugKeys2.length;
+    while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys2[length]];
+    return NullProtoObject();
+  };
+  hiddenKeys2[IE_PROTO] = true;
+  objectCreate = Object.create || function create(O, Properties) {
+    var result;
+    if (O !== null) {
+      EmptyConstructor[PROTOTYPE] = anObject2(O);
+      result = new EmptyConstructor();
+      EmptyConstructor[PROTOTYPE] = null;
+      result[IE_PROTO] = O;
+    } else result = NullProtoObject();
+    return Properties === void 0 ? result : definePropertiesModule.f(result, Properties);
+  };
+  return objectCreate;
+}
+var iteratorsCore;
+var hasRequiredIteratorsCore;
+function requireIteratorsCore() {
+  if (hasRequiredIteratorsCore) return iteratorsCore;
+  hasRequiredIteratorsCore = 1;
+  var fails2 = requireFails();
+  var isCallable2 = requireIsCallable();
+  var isObject2 = requireIsObject$1();
+  var create = requireObjectCreate();
+  var getPrototypeOf = requireObjectGetPrototypeOf();
+  var defineBuiltIn2 = requireDefineBuiltIn();
+  var wellKnownSymbol2 = requireWellKnownSymbol();
+  var IS_PURE = requireIsPure();
+  var ITERATOR = wellKnownSymbol2("iterator");
+  var BUGGY_SAFARI_ITERATORS = false;
+  var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
+  if ([].keys) {
+    arrayIterator = [].keys();
+    if (!("next" in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
+    else {
+      PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
+      if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
+    }
+  }
+  var NEW_ITERATOR_PROTOTYPE = !isObject2(IteratorPrototype) || fails2(function() {
+    var test = {};
+    return IteratorPrototype[ITERATOR].call(test) !== test;
+  });
+  if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
+  else if (IS_PURE) IteratorPrototype = create(IteratorPrototype);
+  if (!isCallable2(IteratorPrototype[ITERATOR])) {
+    defineBuiltIn2(IteratorPrototype, ITERATOR, function() {
+      return this;
+    });
+  }
+  iteratorsCore = {
+    IteratorPrototype,
+    BUGGY_SAFARI_ITERATORS
+  };
+  return iteratorsCore;
+}
+var hasRequiredEs_iterator_constructor;
+function requireEs_iterator_constructor() {
+  if (hasRequiredEs_iterator_constructor) return es_iterator_constructor;
+  hasRequiredEs_iterator_constructor = 1;
+  var $ = require_export();
+  var globalThis2 = requireGlobalThis();
+  var anInstance2 = requireAnInstance();
+  var anObject2 = requireAnObject();
+  var isCallable2 = requireIsCallable();
+  var getPrototypeOf = requireObjectGetPrototypeOf();
+  var defineBuiltInAccessor2 = requireDefineBuiltInAccessor();
+  var createProperty2 = requireCreateProperty();
+  var fails2 = requireFails();
+  var hasOwn = requireHasOwnProperty();
+  var wellKnownSymbol2 = requireWellKnownSymbol();
+  var IteratorPrototype = requireIteratorsCore().IteratorPrototype;
+  var DESCRIPTORS = requireDescriptors();
+  var IS_PURE = requireIsPure();
+  var CONSTRUCTOR = "constructor";
+  var ITERATOR = "Iterator";
+  var TO_STRING_TAG = wellKnownSymbol2("toStringTag");
+  var $TypeError = TypeError;
+  var NativeIterator = globalThis2[ITERATOR];
+  var FORCED = IS_PURE || !isCallable2(NativeIterator) || NativeIterator.prototype !== IteratorPrototype || !fails2(function() {
+    NativeIterator({});
+  });
+  var IteratorConstructor = function Iterator() {
+    anInstance2(this, IteratorPrototype);
+    if (getPrototypeOf(this) === IteratorPrototype) throw new $TypeError("Abstract class Iterator not directly constructable");
+  };
+  var defineIteratorPrototypeAccessor = function(key, value) {
+    if (DESCRIPTORS) {
+      defineBuiltInAccessor2(IteratorPrototype, key, {
+        configurable: true,
+        get: function() {
+          return value;
+        },
+        set: function(replacement) {
+          anObject2(this);
+          if (this === IteratorPrototype) throw new $TypeError("You can't redefine this property");
+          if (hasOwn(this, key)) this[key] = replacement;
+          else createProperty2(this, key, replacement);
+        }
+      });
+    } else IteratorPrototype[key] = value;
+  };
+  if (!hasOwn(IteratorPrototype, TO_STRING_TAG)) defineIteratorPrototypeAccessor(TO_STRING_TAG, ITERATOR);
+  if (FORCED || !hasOwn(IteratorPrototype, CONSTRUCTOR) || IteratorPrototype[CONSTRUCTOR] === Object) {
+    defineIteratorPrototypeAccessor(CONSTRUCTOR, IteratorConstructor);
+  }
+  IteratorConstructor.prototype = IteratorPrototype;
+  $({
+    global: true,
+    constructor: true,
+    forced: FORCED
+  }, {
+    Iterator: IteratorConstructor
+  });
+  return es_iterator_constructor;
+}
+requireEs_iterator_constructor();
+var es_iterator_forEach = {};
+var functionUncurryThisClause;
+var hasRequiredFunctionUncurryThisClause;
+function requireFunctionUncurryThisClause() {
+  if (hasRequiredFunctionUncurryThisClause) return functionUncurryThisClause;
+  hasRequiredFunctionUncurryThisClause = 1;
+  var classofRaw2 = requireClassofRaw();
+  var uncurryThis = requireFunctionUncurryThis();
+  functionUncurryThisClause = function(fn2) {
+    if (classofRaw2(fn2) === "Function") return uncurryThis(fn2);
+  };
+  return functionUncurryThisClause;
+}
+var functionBindContext;
+var hasRequiredFunctionBindContext;
+function requireFunctionBindContext() {
+  if (hasRequiredFunctionBindContext) return functionBindContext;
+  hasRequiredFunctionBindContext = 1;
+  var uncurryThis = requireFunctionUncurryThisClause();
+  var aCallable2 = requireACallable();
+  var NATIVE_BIND = requireFunctionBindNative();
+  var bind = uncurryThis(uncurryThis.bind);
+  functionBindContext = function(fn2, that) {
+    aCallable2(fn2);
+    return that === void 0 ? fn2 : NATIVE_BIND ? bind(fn2, that) : function() {
+      return fn2.apply(that, arguments);
+    };
+  };
+  return functionBindContext;
+}
+var iterators;
+var hasRequiredIterators;
+function requireIterators() {
+  if (hasRequiredIterators) return iterators;
+  hasRequiredIterators = 1;
+  iterators = {};
+  return iterators;
+}
+var isArrayIteratorMethod;
+var hasRequiredIsArrayIteratorMethod;
+function requireIsArrayIteratorMethod() {
+  if (hasRequiredIsArrayIteratorMethod) return isArrayIteratorMethod;
+  hasRequiredIsArrayIteratorMethod = 1;
+  var wellKnownSymbol2 = requireWellKnownSymbol();
+  var Iterators = requireIterators();
+  var ITERATOR = wellKnownSymbol2("iterator");
+  var ArrayPrototype = Array.prototype;
+  isArrayIteratorMethod = function(it) {
+    return it !== void 0 && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+  };
+  return isArrayIteratorMethod;
+}
+var toStringTagSupport;
+var hasRequiredToStringTagSupport;
+function requireToStringTagSupport() {
+  if (hasRequiredToStringTagSupport) return toStringTagSupport;
+  hasRequiredToStringTagSupport = 1;
+  var wellKnownSymbol2 = requireWellKnownSymbol();
+  var TO_STRING_TAG = wellKnownSymbol2("toStringTag");
+  var test = {};
+  test[TO_STRING_TAG] = "z";
+  toStringTagSupport = String(test) === "[object z]";
+  return toStringTagSupport;
+}
+var classof;
+var hasRequiredClassof;
+function requireClassof() {
+  if (hasRequiredClassof) return classof;
+  hasRequiredClassof = 1;
+  var TO_STRING_TAG_SUPPORT = requireToStringTagSupport();
+  var isCallable2 = requireIsCallable();
+  var classofRaw2 = requireClassofRaw();
+  var wellKnownSymbol2 = requireWellKnownSymbol();
+  var TO_STRING_TAG = wellKnownSymbol2("toStringTag");
+  var $Object = Object;
+  var CORRECT_ARGUMENTS = classofRaw2(/* @__PURE__ */ function() {
+    return arguments;
+  }()) === "Arguments";
+  var tryGet = function(it, key) {
+    try {
+      return it[key];
+    } catch (error) {
+    }
+  };
+  classof = TO_STRING_TAG_SUPPORT ? classofRaw2 : function(it) {
+    var O, tag, result;
+    return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw2(O) : (result = classofRaw2(O)) === "Object" && isCallable2(O.callee) ? "Arguments" : result;
+  };
+  return classof;
+}
+var getIteratorMethod;
+var hasRequiredGetIteratorMethod;
+function requireGetIteratorMethod() {
+  if (hasRequiredGetIteratorMethod) return getIteratorMethod;
+  hasRequiredGetIteratorMethod = 1;
+  var classof2 = requireClassof();
+  var getMethod2 = requireGetMethod();
+  var isNullOrUndefined2 = requireIsNullOrUndefined();
+  var Iterators = requireIterators();
+  var wellKnownSymbol2 = requireWellKnownSymbol();
+  var ITERATOR = wellKnownSymbol2("iterator");
+  getIteratorMethod = function(it) {
+    if (!isNullOrUndefined2(it)) return getMethod2(it, ITERATOR) || getMethod2(it, "@@iterator") || Iterators[classof2(it)];
+  };
+  return getIteratorMethod;
+}
+var getIterator;
+var hasRequiredGetIterator;
+function requireGetIterator() {
+  if (hasRequiredGetIterator) return getIterator;
+  hasRequiredGetIterator = 1;
+  var call = requireFunctionCall();
+  var aCallable2 = requireACallable();
+  var anObject2 = requireAnObject();
+  var tryToString2 = requireTryToString();
+  var getIteratorMethod2 = requireGetIteratorMethod();
+  var $TypeError = TypeError;
+  getIterator = function(argument, usingIterator) {
+    var iteratorMethod = arguments.length < 2 ? getIteratorMethod2(argument) : usingIterator;
+    if (aCallable2(iteratorMethod)) return anObject2(call(iteratorMethod, argument));
+    throw new $TypeError(tryToString2(argument) + " is not iterable");
+  };
+  return getIterator;
+}
+var iteratorClose;
+var hasRequiredIteratorClose;
+function requireIteratorClose() {
+  if (hasRequiredIteratorClose) return iteratorClose;
+  hasRequiredIteratorClose = 1;
+  var call = requireFunctionCall();
+  var anObject2 = requireAnObject();
+  var getMethod2 = requireGetMethod();
+  iteratorClose = function(iterator, kind, value) {
+    var innerResult, innerError;
+    anObject2(iterator);
+    try {
+      innerResult = getMethod2(iterator, "return");
+      if (!innerResult) {
+        if (kind === "throw") throw value;
+        return value;
+      }
+      innerResult = call(innerResult, iterator);
+    } catch (error) {
+      innerError = true;
+      innerResult = error;
+    }
+    if (kind === "throw") throw value;
+    if (innerError) throw innerResult;
+    anObject2(innerResult);
+    return value;
+  };
+  return iteratorClose;
+}
+var iterate;
+var hasRequiredIterate;
+function requireIterate() {
+  if (hasRequiredIterate) return iterate;
+  hasRequiredIterate = 1;
+  var bind = requireFunctionBindContext();
+  var call = requireFunctionCall();
+  var anObject2 = requireAnObject();
+  var tryToString2 = requireTryToString();
+  var isArrayIteratorMethod2 = requireIsArrayIteratorMethod();
+  var lengthOfArrayLike2 = requireLengthOfArrayLike();
+  var isPrototypeOf = requireObjectIsPrototypeOf();
+  var getIterator2 = requireGetIterator();
+  var getIteratorMethod2 = requireGetIteratorMethod();
+  var iteratorClose2 = requireIteratorClose();
+  var $TypeError = TypeError;
+  var Result = function(stopped, result) {
+    this.stopped = stopped;
+    this.result = result;
+  };
+  var ResultPrototype = Result.prototype;
+  iterate = function(iterable, unboundFunction, options) {
+    var that = options && options.that;
+    var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+    var IS_RECORD = !!(options && options.IS_RECORD);
+    var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+    var INTERRUPTED = !!(options && options.INTERRUPTED);
+    var fn2 = bind(unboundFunction, that);
+    var iterator, iterFn, index, length, result, next, step;
+    var stop = function(condition) {
+      if (iterator) iteratorClose2(iterator, "normal", condition);
+      return new Result(true, condition);
+    };
+    var callFn = function(value) {
+      if (AS_ENTRIES) {
+        anObject2(value);
+        return INTERRUPTED ? fn2(value[0], value[1], stop) : fn2(value[0], value[1]);
+      }
+      return INTERRUPTED ? fn2(value, stop) : fn2(value);
+    };
+    if (IS_RECORD) {
+      iterator = iterable.iterator;
+    } else if (IS_ITERATOR) {
+      iterator = iterable;
+    } else {
+      iterFn = getIteratorMethod2(iterable);
+      if (!iterFn) throw new $TypeError(tryToString2(iterable) + " is not iterable");
+      if (isArrayIteratorMethod2(iterFn)) {
+        for (index = 0, length = lengthOfArrayLike2(iterable); length > index; index++) {
+          result = callFn(iterable[index]);
+          if (result && isPrototypeOf(ResultPrototype, result)) return result;
+        }
+        return new Result(false);
+      }
+      iterator = getIterator2(iterable, iterFn);
+    }
+    next = IS_RECORD ? iterable.next : iterator.next;
+    while (!(step = call(next, iterator)).done) {
+      try {
+        result = callFn(step.value);
+      } catch (error) {
+        iteratorClose2(iterator, "throw", error);
+      }
+      if (typeof result == "object" && result && isPrototypeOf(ResultPrototype, result)) return result;
+    }
+    return new Result(false);
+  };
+  return iterate;
+}
+var getIteratorDirect;
+var hasRequiredGetIteratorDirect;
+function requireGetIteratorDirect() {
+  if (hasRequiredGetIteratorDirect) return getIteratorDirect;
+  hasRequiredGetIteratorDirect = 1;
+  getIteratorDirect = function(obj) {
+    return {
+      iterator: obj,
+      next: obj.next,
+      done: false
+    };
+  };
+  return getIteratorDirect;
+}
+var hasRequiredEs_iterator_forEach;
+function requireEs_iterator_forEach() {
+  if (hasRequiredEs_iterator_forEach) return es_iterator_forEach;
+  hasRequiredEs_iterator_forEach = 1;
+  var $ = require_export();
+  var iterate2 = requireIterate();
+  var aCallable2 = requireACallable();
+  var anObject2 = requireAnObject();
+  var getIteratorDirect2 = requireGetIteratorDirect();
+  $({
+    target: "Iterator",
+    proto: true,
+    real: true
+  }, {
+    forEach: function forEach(fn2) {
+      anObject2(this);
+      aCallable2(fn2);
+      var record = getIteratorDirect2(this);
+      var counter = 0;
+      iterate2(record, function(value) {
+        fn2(value, counter++);
+      }, {
+        IS_RECORD: true
+      });
+    }
+  });
+  return es_iterator_forEach;
+}
+requireEs_iterator_forEach();
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var es_array_push = {};
 var isArray;
 var hasRequiredIsArray$1;
 function requireIsArray$1() {
   if (hasRequiredIsArray$1) return isArray;
   hasRequiredIsArray$1 = 1;
-  var classof = requireClassofRaw();
+  var classof2 = requireClassofRaw();
   isArray = Array.isArray || function isArray2(argument) {
-    return classof(argument) === "Array";
+    return classof2(argument) === "Array";
   };
   return isArray;
 }
@@ -1994,6 +2555,165 @@ function require_mapCacheClear() {
   _mapCacheClear = mapCacheClear;
   return _mapCacheClear;
 }
+var es_iterator_map = {};
+var defineBuiltIns;
+var hasRequiredDefineBuiltIns;
+function requireDefineBuiltIns() {
+  if (hasRequiredDefineBuiltIns) return defineBuiltIns;
+  hasRequiredDefineBuiltIns = 1;
+  var defineBuiltIn2 = requireDefineBuiltIn();
+  defineBuiltIns = function(target, src, options) {
+    for (var key in src) defineBuiltIn2(target, key, src[key], options);
+    return target;
+  };
+  return defineBuiltIns;
+}
+var createIterResultObject;
+var hasRequiredCreateIterResultObject;
+function requireCreateIterResultObject() {
+  if (hasRequiredCreateIterResultObject) return createIterResultObject;
+  hasRequiredCreateIterResultObject = 1;
+  createIterResultObject = function(value, done) {
+    return {
+      value,
+      done
+    };
+  };
+  return createIterResultObject;
+}
+var iteratorCreateProxy;
+var hasRequiredIteratorCreateProxy;
+function requireIteratorCreateProxy() {
+  if (hasRequiredIteratorCreateProxy) return iteratorCreateProxy;
+  hasRequiredIteratorCreateProxy = 1;
+  var call = requireFunctionCall();
+  var create = requireObjectCreate();
+  var createNonEnumerableProperty2 = requireCreateNonEnumerableProperty();
+  var defineBuiltIns2 = requireDefineBuiltIns();
+  var wellKnownSymbol2 = requireWellKnownSymbol();
+  var InternalStateModule = requireInternalState();
+  var getMethod2 = requireGetMethod();
+  var IteratorPrototype = requireIteratorsCore().IteratorPrototype;
+  var createIterResultObject2 = requireCreateIterResultObject();
+  var iteratorClose2 = requireIteratorClose();
+  var TO_STRING_TAG = wellKnownSymbol2("toStringTag");
+  var ITERATOR_HELPER = "IteratorHelper";
+  var WRAP_FOR_VALID_ITERATOR = "WrapForValidIterator";
+  var setInternalState = InternalStateModule.set;
+  var createIteratorProxyPrototype = function(IS_ITERATOR) {
+    var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);
+    return defineBuiltIns2(create(IteratorPrototype), {
+      next: function next() {
+        var state = getInternalState(this);
+        if (IS_ITERATOR) return state.nextHandler();
+        if (state.done) return createIterResultObject2(void 0, true);
+        try {
+          var result = state.nextHandler();
+          return state.returnHandlerResult ? result : createIterResultObject2(result, state.done);
+        } catch (error) {
+          state.done = true;
+          throw error;
+        }
+      },
+      "return": function() {
+        var state = getInternalState(this);
+        var iterator = state.iterator;
+        state.done = true;
+        if (IS_ITERATOR) {
+          var returnMethod = getMethod2(iterator, "return");
+          return returnMethod ? call(returnMethod, iterator) : createIterResultObject2(void 0, true);
+        }
+        if (state.inner) try {
+          iteratorClose2(state.inner.iterator, "normal");
+        } catch (error) {
+          return iteratorClose2(iterator, "throw", error);
+        }
+        if (iterator) iteratorClose2(iterator, "normal");
+        return createIterResultObject2(void 0, true);
+      }
+    });
+  };
+  var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
+  var IteratorHelperPrototype = createIteratorProxyPrototype(false);
+  createNonEnumerableProperty2(IteratorHelperPrototype, TO_STRING_TAG, "Iterator Helper");
+  iteratorCreateProxy = function(nextHandler, IS_ITERATOR, RETURN_HANDLER_RESULT) {
+    var IteratorProxy = function Iterator(record, state) {
+      if (state) {
+        state.iterator = record.iterator;
+        state.next = record.next;
+      } else state = record;
+      state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
+      state.returnHandlerResult = !!RETURN_HANDLER_RESULT;
+      state.nextHandler = nextHandler;
+      state.counter = 0;
+      state.done = false;
+      setInternalState(this, state);
+    };
+    IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;
+    return IteratorProxy;
+  };
+  return iteratorCreateProxy;
+}
+var callWithSafeIterationClosing;
+var hasRequiredCallWithSafeIterationClosing;
+function requireCallWithSafeIterationClosing() {
+  if (hasRequiredCallWithSafeIterationClosing) return callWithSafeIterationClosing;
+  hasRequiredCallWithSafeIterationClosing = 1;
+  var anObject2 = requireAnObject();
+  var iteratorClose2 = requireIteratorClose();
+  callWithSafeIterationClosing = function(iterator, fn2, value, ENTRIES) {
+    try {
+      return ENTRIES ? fn2(anObject2(value)[0], value[1]) : fn2(value);
+    } catch (error) {
+      iteratorClose2(iterator, "throw", error);
+    }
+  };
+  return callWithSafeIterationClosing;
+}
+var iteratorMap;
+var hasRequiredIteratorMap;
+function requireIteratorMap() {
+  if (hasRequiredIteratorMap) return iteratorMap;
+  hasRequiredIteratorMap = 1;
+  var call = requireFunctionCall();
+  var aCallable2 = requireACallable();
+  var anObject2 = requireAnObject();
+  var getIteratorDirect2 = requireGetIteratorDirect();
+  var createIteratorProxy = requireIteratorCreateProxy();
+  var callWithSafeIterationClosing2 = requireCallWithSafeIterationClosing();
+  var IteratorProxy = createIteratorProxy(function() {
+    var iterator = this.iterator;
+    var result = anObject2(call(this.next, iterator));
+    var done = this.done = !!result.done;
+    if (!done) return callWithSafeIterationClosing2(iterator, this.mapper, [result.value, this.counter++], true);
+  });
+  iteratorMap = function map(mapper) {
+    anObject2(this);
+    aCallable2(mapper);
+    return new IteratorProxy(getIteratorDirect2(this), {
+      mapper
+    });
+  };
+  return iteratorMap;
+}
+var hasRequiredEs_iterator_map;
+function requireEs_iterator_map() {
+  if (hasRequiredEs_iterator_map) return es_iterator_map;
+  hasRequiredEs_iterator_map = 1;
+  var $ = require_export();
+  var map = requireIteratorMap();
+  var IS_PURE = requireIsPure();
+  $({
+    target: "Iterator",
+    proto: true,
+    real: true,
+    forced: IS_PURE
+  }, {
+    map
+  });
+  return es_iterator_map;
+}
+requireEs_iterator_map();
 var _isKeyable;
 var hasRequired_isKeyable;
 function require_isKeyable() {
@@ -2804,24 +3524,6 @@ function require_equalObjects() {
   return _equalObjects;
 }
 var es_arrayBuffer_detached = {};
-var defineBuiltInAccessor;
-var hasRequiredDefineBuiltInAccessor;
-function requireDefineBuiltInAccessor() {
-  if (hasRequiredDefineBuiltInAccessor) return defineBuiltInAccessor;
-  hasRequiredDefineBuiltInAccessor = 1;
-  var makeBuiltIn2 = requireMakeBuiltIn();
-  var defineProperty = requireObjectDefineProperty();
-  defineBuiltInAccessor = function(target, name, descriptor) {
-    if (descriptor.get) makeBuiltIn2(descriptor.get, name, {
-      getter: true
-    });
-    if (descriptor.set) makeBuiltIn2(descriptor.set, name, {
-      setter: true
-    });
-    return defineProperty.f(target, name, descriptor);
-  };
-  return defineBuiltInAccessor;
-}
 var arrayBufferBasicDetection;
 var hasRequiredArrayBufferBasicDetection;
 function requireArrayBufferBasicDetection() {
@@ -2852,11 +3554,11 @@ function requireArrayBufferByteLength() {
   hasRequiredArrayBufferByteLength = 1;
   var globalThis2 = requireGlobalThis();
   var uncurryThisAccessor = requireFunctionUncurryThisAccessor();
-  var classof = requireClassofRaw();
+  var classof2 = requireClassofRaw();
   var ArrayBuffer2 = globalThis2.ArrayBuffer;
   var TypeError2 = globalThis2.TypeError;
   arrayBufferByteLength = ArrayBuffer2 && uncurryThisAccessor(ArrayBuffer2.prototype, "byteLength", "get") || function(O) {
-    if (classof(O) !== "ArrayBuffer") throw new TypeError2("ArrayBuffer expected");
+    if (classof2(O) !== "ArrayBuffer") throw new TypeError2("ArrayBuffer expected");
     return O.byteLength;
   };
   return arrayBufferByteLength;
@@ -2938,7 +3640,7 @@ function requireEnvironment() {
   hasRequiredEnvironment = 1;
   var globalThis2 = requireGlobalThis();
   var userAgent = requireEnvironmentUserAgent();
-  var classof = requireClassofRaw();
+  var classof2 = requireClassofRaw();
   var userAgentStartsWith = function(string) {
     return userAgent.slice(0, string.length) === string;
   };
@@ -2949,7 +3651,7 @@ function requireEnvironment() {
     if (userAgentStartsWith("Node.js/")) return "NODE";
     if (globalThis2.Bun && typeof Bun.version == "string") return "BUN";
     if (globalThis2.Deno && typeof Deno.version == "object") return "DENO";
-    if (classof(globalThis2.process) === "process") return "NODE";
+    if (classof2(globalThis2.process) === "process") return "NODE";
     if (globalThis2.window && globalThis2.document) return "BROWSER";
     return "REST";
   }();
@@ -3281,6 +3983,37 @@ function requireIsEqual() {
 }
 var isEqualExports = requireIsEqual();
 const isEqual$1 = /* @__PURE__ */ getDefaultExportFromCjs(isEqualExports);
+var es_iterator_find = {};
+var hasRequiredEs_iterator_find;
+function requireEs_iterator_find() {
+  if (hasRequiredEs_iterator_find) return es_iterator_find;
+  hasRequiredEs_iterator_find = 1;
+  var $ = require_export();
+  var iterate2 = requireIterate();
+  var aCallable2 = requireACallable();
+  var anObject2 = requireAnObject();
+  var getIteratorDirect2 = requireGetIteratorDirect();
+  $({
+    target: "Iterator",
+    proto: true,
+    real: true
+  }, {
+    find: function find(predicate) {
+      anObject2(this);
+      aCallable2(predicate);
+      var record = getIteratorDirect2(this);
+      var counter = 0;
+      return iterate2(record, function(value, stop) {
+        if (predicate(value, counter++)) return stop(value);
+      }, {
+        IS_RECORD: true,
+        INTERRUPTED: true
+      }).result;
+    }
+  });
+  return es_iterator_find;
+}
+requireEs_iterator_find();
 function itemEquals(item1, item2, compareAttribute) {
   if (!isSet(item1) || !isSet(item2)) {
     return false;
@@ -4365,6 +5098,80 @@ function _sfc_render$R(_ctx, _cache, $props, $setup, $data, $options) {
   })]);
 }
 const FErrorList = /* @__PURE__ */ _export_sfc(_sfc_main$15, [["render", _sfc_render$R]]);
+var es_iterator_every = {};
+var hasRequiredEs_iterator_every;
+function requireEs_iterator_every() {
+  if (hasRequiredEs_iterator_every) return es_iterator_every;
+  hasRequiredEs_iterator_every = 1;
+  var $ = require_export();
+  var iterate2 = requireIterate();
+  var aCallable2 = requireACallable();
+  var anObject2 = requireAnObject();
+  var getIteratorDirect2 = requireGetIteratorDirect();
+  $({
+    target: "Iterator",
+    proto: true,
+    real: true
+  }, {
+    every: function every(predicate) {
+      anObject2(this);
+      aCallable2(predicate);
+      var record = getIteratorDirect2(this);
+      var counter = 0;
+      return !iterate2(record, function(value, stop) {
+        if (!predicate(value, counter++)) return stop();
+      }, {
+        IS_RECORD: true,
+        INTERRUPTED: true
+      }).stopped;
+    }
+  });
+  return es_iterator_every;
+}
+requireEs_iterator_every();
+var es_iterator_filter = {};
+var hasRequiredEs_iterator_filter;
+function requireEs_iterator_filter() {
+  if (hasRequiredEs_iterator_filter) return es_iterator_filter;
+  hasRequiredEs_iterator_filter = 1;
+  var $ = require_export();
+  var call = requireFunctionCall();
+  var aCallable2 = requireACallable();
+  var anObject2 = requireAnObject();
+  var getIteratorDirect2 = requireGetIteratorDirect();
+  var createIteratorProxy = requireIteratorCreateProxy();
+  var callWithSafeIterationClosing2 = requireCallWithSafeIterationClosing();
+  var IS_PURE = requireIsPure();
+  var IteratorProxy = createIteratorProxy(function() {
+    var iterator = this.iterator;
+    var predicate = this.predicate;
+    var next = this.next;
+    var result, done, value;
+    while (true) {
+      result = anObject2(call(next, iterator));
+      done = this.done = !!result.done;
+      if (done) return;
+      value = result.value;
+      if (callWithSafeIterationClosing2(iterator, predicate, [value, this.counter++], true)) return value;
+    }
+  });
+  $({
+    target: "Iterator",
+    proto: true,
+    real: true,
+    forced: IS_PURE
+  }, {
+    filter: function filter2(predicate) {
+      anObject2(this);
+      aCallable2(predicate);
+      return new IteratorProxy(getIteratorDirect2(this), {
+        predicate
+      });
+    }
+  });
+  return es_iterator_filter;
+}
+requireEs_iterator_filter();
 function cleanUpElements(vm) {
   return new Promise((resolve) => {
     window.setTimeout(() => {
@@ -8942,6 +9749,37 @@ function _sfc_render$y(_ctx, _cache, $props, $setup, $data, $options) {
   }, 8, ["onEnter", "onAfterEnter", "onLeave"])) : createCommentVNode("", true)], 64)) : createCommentVNode("", true)], 10, _hoisted_2$q)], 34);
 }
 const FCheckboxField = /* @__PURE__ */ _export_sfc(_sfc_main$K, [["render", _sfc_render$y]]);
+var es_iterator_some = {};
+var hasRequiredEs_iterator_some;
+function requireEs_iterator_some() {
+  if (hasRequiredEs_iterator_some) return es_iterator_some;
+  hasRequiredEs_iterator_some = 1;
+  var $ = require_export();
+  var iterate2 = requireIterate();
+  var aCallable2 = requireACallable();
+  var anObject2 = requireAnObject();
+  var getIteratorDirect2 = requireGetIteratorDirect();
+  $({
+    target: "Iterator",
+    proto: true,
+    real: true
+  }, {
+    some: function some(predicate) {
+      anObject2(this);
+      aCallable2(predicate);
+      var record = getIteratorDirect2(this);
+      var counter = 0;
+      return iterate2(record, function(value, stop) {
+        if (predicate(value, counter++)) return stop();
+      }, {
+        IS_RECORD: true,
+        INTERRUPTED: true
+      }).stopped;
+    }
+  });
+  return es_iterator_some;
+}
+requireEs_iterator_some();
 function isContextMenuTextItem(value) {
   return typeof value.key === "string";
 }
@@ -16514,10 +17352,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
       class: "wizard-step-body",
       onSubmit: _ctx.onSubmit
     }, {
-      "error-message": withCtx(() => [renderSlot(_ctx.$slots, "error-message", normalizeProps(guardReactiveProps({
-        stepNumber: _ctx.stepNumber,
-        totalSteps: _ctx.totalSteps
-      })), () => [createTextVNode(toDisplayString(_ctx.$t("fkui.wizard-step.errorlist.title", "Oj, du har glömt att fylla i något. Gå till:")), 1)])]),
+      "error-message": withCtx(() => [renderSlot(_ctx.$slots, "error-message", {}, () => [createTextVNode(toDisplayString(_ctx.$t("fkui.wizard-step.errorlist.title", "Oj, du har glömt att fylla i något. Gå till:")), 1)])]),
       default: withCtx(() => [renderSlot(_ctx.$slots, "default"), _cache[14] || (_cache[14] = createTextVNode()), createElementVNode("div", _hoisted_10, [createElementVNode("button", {
         "data-test": "submit-button",
         "data-disabled": _ctx.ignoreClick ? "true" : "false",
@@ -16535,7 +17370,10 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
         type: "button",
         class: "button button--secondary button-group__item button--large",
         onClick: _cache[2] || (_cache[2] = (...args) => _ctx.onCancel && _ctx.onCancel(...args))
-      }, [renderSlot(_ctx.$slots, "cancel-button-text", {}, () => [createTextVNode(toDisplayString(_ctx.$t("fkui.wizard-step.button.cancel.text", "Avbryt")), 1)])])])]),
+      }, [renderSlot(_ctx.$slots, "cancel-button-text", normalizeProps(guardReactiveProps({
+        stepNumber: _ctx.stepNumber,
+        totalSteps: _ctx.totalSteps
+      })), () => [createTextVNode(toDisplayString(_ctx.$t("fkui.wizard-step.button.cancel.text", "Avbryt")), 1)])])])]),
       _: 3
     }, 8, ["id", "before-submit", "before-validation", "use-error-list", "onSubmit"])]),
     _: 3