@fkui/logic 5.36.0

package/lib/esm/index.js

@@ -0,0 +1,5047 @@
+/**
+ * @public
+ */
+const configLogic = {
+    production: true,
+};
+
+/**
+ * Determine if a value is empty.
+ *
+ * A value is considered empty if it is:
+ *
+ * - `undefined`
+ * - `null`
+ * - empty string `""`.
+ *
+ * @public
+ * @param value - value to check if it is empty
+ */
+function isEmpty(value) {
+    return !value;
+}
+
+/**
+ * Determine if a value is set. If it is undefined or null, this function
+ * returns false.
+ *
+ * @public
+ * @param value - the value for which to determine if it is set
+ */
+function isSet(value) {
+    return value !== undefined && value !== null;
+}
+
+/**
+ * @public
+ */
+function isString(value) {
+    return typeof value === "string" || value instanceof String;
+}
+
+/**
+ * Matches a single whitespace globally.
+ *
+ * @public
+ * @deprecated Use {@link stripWhitespace} instead
+ */
+const WHITESPACE_PATTERN = /\s/g;
+/**
+ * @public
+ * @deprecated Use {@link formatNumber} instead.
+ */
+const FORMAT_3_DIGITS_GROUPS = /\B(?=(\d{3})+(?!\d))/g;
+
+/**
+ * Implementation of Object.fromEntries() until we run a recent enough version
+ * of NodeJS.
+ *
+ * @internal
+ */
+function fromEntries(iterable) {
+    return iterable.reduce((obj, [key, value]) => {
+        obj[key] = value;
+        return obj;
+    }, {});
+}
+/**
+ * Recursively strips null from source parameter.
+ *
+ * - Literals string, numbers etc will be returned as-is.
+ * - Literal `null` will return `undefined`
+ * - Arrays with `null` be replace element with `undefined`, i.e. the length of
+ *   the array is not modified.
+ * - Object values with `null` will be removed, i.e. `hasOwnProperty(..)` will
+ *   return `false`.
+ *
+ * @public
+ * @param src - Source value
+ * @returns A copy of the source parameter with any null stripped
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any -- technical debt */
+function stripNull(src) {
+    /* handle literal null */
+    if (src === null) {
+        return undefined;
+    }
+    /* handle arrays recursively */
+    if (Array.isArray(src)) {
+        return src.map(stripNull);
+    }
+    /* handle pod literals such as string, number, etc */
+    if (typeof src !== "object") {
+        return src;
+    }
+    /* unpack object to a [key, value] array */
+    const entries = Object.entries(src)
+        /* filter out any entries where value is null */
+        .filter(([, value]) => value !== null)
+        /* recursively replace values from the [key, value] array */
+        .map(([key, value]) => {
+        return [key, stripNull(value)];
+    });
+    /* reconstruct a new object from the [key, value] array */
+    return fromEntries(entries);
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+/**
+ * Decorates an original error with more information while
+ * keeping the original intact.
+ *
+ * @public
+ */
+class DecoratedError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        Object.setPrototypeOf(this, DecoratedError.prototype);
+        this.stack += `\nCaused by: ${cause.stack}`;
+        this.cause = cause;
+    }
+    /**
+     * Get the direct cause of this error, the one that triggered
+     * this error.
+     */
+    getCause() {
+        return this.cause;
+    }
+    /**
+     * Get the root cause of this error, the first error that occured.
+     */
+    getRootCause() {
+        const cause = this.cause;
+        if (cause instanceof DecoratedError) {
+            return cause.getRootCause();
+        }
+        return cause;
+    }
+}
+
+/**
+ * @public
+ * @deprecated Use `FDate` instead.
+ */
+const DATE_REGEXP_WITH_DASH = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
+/**
+ * @public
+ */
+function validLimit(limit) {
+    if (typeof limit !== "string" || isEmpty(limit)) {
+        throw new Error(`limit must be a non-empty string`);
+    }
+    const limitAsString = limit;
+    if (!DATE_REGEXP_WITH_DASH.test(limitAsString)) {
+        throw new Error(`limit has invalid format`);
+    }
+    return limitAsString;
+}
+
+/**
+ * Executes a function when it stops being invoked for n seconds. Usually used together with resize,
+ * scroll and keyup/keydown-events to improve application's performance.
+ *
+ * Example:
+ *
+ * ```
+ *    window.addEventListener(
+ *        'resize',
+ *        debounce(computationalHeavyFunction, 1000),
+ *    );
+ * ```
+ *
+ * This will call the `computationalHeavyFunction` once if the resize-event hasn't been sent for 1000 ms.
+ *
+ * Example with immediate-flag:
+ *
+ * ```
+ *    window.addEventListener(
+ *        'resize',
+ *        debounce(computationalHeavyFunction, 1000, true),
+ *    );
+ * ```
+ *
+ * This will call the `computationalHeavyFunction` once BEFORE the resize-event has finished,
+ * and thereafter will not be able to be called again until the timeout has finished
+ *
+ * @public
+ * @param func - Function to be debounced.
+ * @param delay - Function execution threshold in milliseconds.
+ * @param immediate - Whether the function should be called at the beginning of the delay (Before the timeout) instead of the end.
+ * Default is false.
+ */
+function debounce(func, delay, immediate = false) {
+    let timeout = null;
+    return function functionToExecute(...args) {
+        const timedOutFunction = () => {
+            timeout = null;
+            if (!immediate) {
+                func.apply(this, args);
+            }
+        };
+        const callNow = immediate && !timeout;
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(timedOutFunction, delay);
+        if (callNow) {
+            func.apply(this);
+        }
+    };
+}
+
+var commonjsGlobal$1 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs$1 (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var lodash_clonedeep = {exports: {}};
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+lodash_clonedeep.exports;
+
+(function (module, exports) {
+	/** Used as the size to enable large array optimizations. */
+	var LARGE_ARRAY_SIZE = 200;
+
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+	/** Used as references for various `Number` constants. */
+	var MAX_SAFE_INTEGER = 9007199254740991;
+
+	/** `Object#toString` result references. */
+	var argsTag = '[object Arguments]',
+	    arrayTag = '[object Array]',
+	    boolTag = '[object Boolean]',
+	    dateTag = '[object Date]',
+	    errorTag = '[object Error]',
+	    funcTag = '[object Function]',
+	    genTag = '[object GeneratorFunction]',
+	    mapTag = '[object Map]',
+	    numberTag = '[object Number]',
+	    objectTag = '[object Object]',
+	    promiseTag = '[object Promise]',
+	    regexpTag = '[object RegExp]',
+	    setTag = '[object Set]',
+	    stringTag = '[object String]',
+	    symbolTag = '[object Symbol]',
+	    weakMapTag = '[object WeakMap]';
+
+	var arrayBufferTag = '[object ArrayBuffer]',
+	    dataViewTag = '[object DataView]',
+	    float32Tag = '[object Float32Array]',
+	    float64Tag = '[object Float64Array]',
+	    int8Tag = '[object Int8Array]',
+	    int16Tag = '[object Int16Array]',
+	    int32Tag = '[object Int32Array]',
+	    uint8Tag = '[object Uint8Array]',
+	    uint8ClampedTag = '[object Uint8ClampedArray]',
+	    uint16Tag = '[object Uint16Array]',
+	    uint32Tag = '[object Uint32Array]';
+
+	/**
+	 * Used to match `RegExp`
+	 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+	 */
+	var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+	/** Used to match `RegExp` flags from their coerced string values. */
+	var reFlags = /\w*$/;
+
+	/** Used to detect host constructors (Safari). */
+	var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+	/** Used to detect unsigned integer values. */
+	var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+	/** Used to identify `toStringTag` values supported by `_.clone`. */
+	var cloneableTags = {};
+	cloneableTags[argsTag] = cloneableTags[arrayTag] =
+	cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+	cloneableTags[boolTag] = cloneableTags[dateTag] =
+	cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+	cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+	cloneableTags[int32Tag] = cloneableTags[mapTag] =
+	cloneableTags[numberTag] = cloneableTags[objectTag] =
+	cloneableTags[regexpTag] = cloneableTags[setTag] =
+	cloneableTags[stringTag] = cloneableTags[symbolTag] =
+	cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+	cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+	cloneableTags[errorTag] = cloneableTags[funcTag] =
+	cloneableTags[weakMapTag] = false;
+
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal = typeof commonjsGlobal$1 == 'object' && commonjsGlobal$1 && commonjsGlobal$1.Object === Object && commonjsGlobal$1;
+
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+	/** Used as a reference to the global object. */
+	var root = freeGlobal || freeSelf || Function('return this')();
+
+	/** Detect free variable `exports`. */
+	var freeExports = exports && !exports.nodeType && exports;
+
+	/** Detect free variable `module`. */
+	var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+	/** Detect the popular CommonJS extension `module.exports`. */
+	var moduleExports = freeModule && freeModule.exports === freeExports;
+
+	/**
+	 * Adds the key-value `pair` to `map`.
+	 *
+	 * @private
+	 * @param {Object} map The map to modify.
+	 * @param {Array} pair The key-value pair to add.
+	 * @returns {Object} Returns `map`.
+	 */
+	function addMapEntry(map, pair) {
+	  // Don't return `map.set` because it's not chainable in IE 11.
+	  map.set(pair[0], pair[1]);
+	  return map;
+	}
+
+	/**
+	 * Adds `value` to `set`.
+	 *
+	 * @private
+	 * @param {Object} set The set to modify.
+	 * @param {*} value The value to add.
+	 * @returns {Object} Returns `set`.
+	 */
+	function addSetEntry(set, value) {
+	  // Don't return `set.add` because it's not chainable in IE 11.
+	  set.add(value);
+	  return set;
+	}
+
+	/**
+	 * A specialized version of `_.forEach` for arrays without support for
+	 * iteratee shorthands.
+	 *
+	 * @private
+	 * @param {Array} [array] The array to iterate over.
+	 * @param {Function} iteratee The function invoked per iteration.
+	 * @returns {Array} Returns `array`.
+	 */
+	function arrayEach(array, iteratee) {
+	  var index = -1,
+	      length = array ? array.length : 0;
+
+	  while (++index < length) {
+	    if (iteratee(array[index], index, array) === false) {
+	      break;
+	    }
+	  }
+	  return array;
+	}
+
+	/**
+	 * Appends the elements of `values` to `array`.
+	 *
+	 * @private
+	 * @param {Array} array The array to modify.
+	 * @param {Array} values The values to append.
+	 * @returns {Array} Returns `array`.
+	 */
+	function arrayPush(array, values) {
+	  var index = -1,
+	      length = values.length,
+	      offset = array.length;
+
+	  while (++index < length) {
+	    array[offset + index] = values[index];
+	  }
+	  return array;
+	}
+
+	/**
+	 * A specialized version of `_.reduce` for arrays without support for
+	 * iteratee shorthands.
+	 *
+	 * @private
+	 * @param {Array} [array] The array to iterate over.
+	 * @param {Function} iteratee The function invoked per iteration.
+	 * @param {*} [accumulator] The initial value.
+	 * @param {boolean} [initAccum] Specify using the first element of `array` as
+	 *  the initial value.
+	 * @returns {*} Returns the accumulated value.
+	 */
+	function arrayReduce(array, iteratee, accumulator, initAccum) {
+	  var index = -1,
+	      length = array ? array.length : 0;
+	  while (++index < length) {
+	    accumulator = iteratee(accumulator, array[index], index, array);
+	  }
+	  return accumulator;
+	}
+
+	/**
+	 * The base implementation of `_.times` without support for iteratee shorthands
+	 * or max array length checks.
+	 *
+	 * @private
+	 * @param {number} n The number of times to invoke `iteratee`.
+	 * @param {Function} iteratee The function invoked per iteration.
+	 * @returns {Array} Returns the array of results.
+	 */
+	function baseTimes(n, iteratee) {
+	  var index = -1,
+	      result = Array(n);
+
+	  while (++index < n) {
+	    result[index] = iteratee(index);
+	  }
+	  return result;
+	}
+
+	/**
+	 * Gets the value at `key` of `object`.
+	 *
+	 * @private
+	 * @param {Object} [object] The object to query.
+	 * @param {string} key The key of the property to get.
+	 * @returns {*} Returns the property value.
+	 */
+	function getValue(object, key) {
+	  return object == null ? undefined : object[key];
+	}
+
+	/**
+	 * Checks if `value` is a host object in IE < 9.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+	 */
+	function isHostObject(value) {
+	  // Many host objects are `Object` objects that can coerce to strings
+	  // despite having improperly defined `toString` methods.
+	  var result = false;
+	  if (value != null && typeof value.toString != 'function') {
+	    try {
+	      result = !!(value + '');
+	    } catch (e) {}
+	  }
+	  return result;
+	}
+
+	/**
+	 * Converts `map` to its key-value pairs.
+	 *
+	 * @private
+	 * @param {Object} map The map to convert.
+	 * @returns {Array} Returns the key-value pairs.
+	 */
+	function mapToArray(map) {
+	  var index = -1,
+	      result = Array(map.size);
+
+	  map.forEach(function(value, key) {
+	    result[++index] = [key, value];
+	  });
+	  return result;
+	}
+
+	/**
+	 * Creates a unary function that invokes `func` with its argument transformed.
+	 *
+	 * @private
+	 * @param {Function} func The function to wrap.
+	 * @param {Function} transform The argument transform.
+	 * @returns {Function} Returns the new function.
+	 */
+	function overArg(func, transform) {
+	  return function(arg) {
+	    return func(transform(arg));
+	  };
+	}
+
+	/**
+	 * Converts `set` to an array of its values.
+	 *
+	 * @private
+	 * @param {Object} set The set to convert.
+	 * @returns {Array} Returns the values.
+	 */
+	function setToArray(set) {
+	  var index = -1,
+	      result = Array(set.size);
+
+	  set.forEach(function(value) {
+	    result[++index] = value;
+	  });
+	  return result;
+	}
+
+	/** Used for built-in method references. */
+	var arrayProto = Array.prototype,
+	    funcProto = Function.prototype,
+	    objectProto = Object.prototype;
+
+	/** Used to detect overreaching core-js shims. */
+	var coreJsData = root['__core-js_shared__'];
+
+	/** Used to detect methods masquerading as native. */
+	var maskSrcKey = (function() {
+	  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+	  return uid ? ('Symbol(src)_1.' + uid) : '';
+	}());
+
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+
+	/**
+	 * Used to resolve the
+	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	 * of values.
+	 */
+	var objectToString = objectProto.toString;
+
+	/** Used to detect if a method is native. */
+	var reIsNative = RegExp('^' +
+	  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+	);
+
+	/** Built-in value references. */
+	var Buffer = moduleExports ? root.Buffer : undefined,
+	    Symbol = root.Symbol,
+	    Uint8Array = root.Uint8Array,
+	    getPrototype = overArg(Object.getPrototypeOf, Object),
+	    objectCreate = Object.create,
+	    propertyIsEnumerable = objectProto.propertyIsEnumerable,
+	    splice = arrayProto.splice;
+
+	/* Built-in method references for those with the same name as other `lodash` methods. */
+	var nativeGetSymbols = Object.getOwnPropertySymbols,
+	    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
+	    nativeKeys = overArg(Object.keys, Object);
+
+	/* Built-in method references that are verified to be native. */
+	var DataView = getNative(root, 'DataView'),
+	    Map = getNative(root, 'Map'),
+	    Promise = getNative(root, 'Promise'),
+	    Set = getNative(root, 'Set'),
+	    WeakMap = getNative(root, 'WeakMap'),
+	    nativeCreate = getNative(Object, 'create');
+
+	/** Used to detect maps, sets, and weakmaps. */
+	var dataViewCtorString = toSource(DataView),
+	    mapCtorString = toSource(Map),
+	    promiseCtorString = toSource(Promise),
+	    setCtorString = toSource(Set),
+	    weakMapCtorString = toSource(WeakMap);
+
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol ? Symbol.prototype : undefined,
+	    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+	/**
+	 * Creates a hash object.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function Hash(entries) {
+	  var index = -1,
+	      length = entries ? entries.length : 0;
+
+	  this.clear();
+	  while (++index < length) {
+	    var entry = entries[index];
+	    this.set(entry[0], entry[1]);
+	  }
+	}
+
+	/**
+	 * Removes all key-value entries from the hash.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf Hash
+	 */
+	function hashClear() {
+	  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+	}
+
+	/**
+	 * Removes `key` and its value from the hash.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf Hash
+	 * @param {Object} hash The hash to modify.
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function hashDelete(key) {
+	  return this.has(key) && delete this.__data__[key];
+	}
+
+	/**
+	 * Gets the hash value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf Hash
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function hashGet(key) {
+	  var data = this.__data__;
+	  if (nativeCreate) {
+	    var result = data[key];
+	    return result === HASH_UNDEFINED ? undefined : result;
+	  }
+	  return hasOwnProperty.call(data, key) ? data[key] : undefined;
+	}
+
+	/**
+	 * Checks if a hash value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf Hash
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function hashHas(key) {
+	  var data = this.__data__;
+	  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+	}
+
+	/**
+	 * Sets the hash `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf Hash
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the hash instance.
+	 */
+	function hashSet(key, value) {
+	  var data = this.__data__;
+	  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+	  return this;
+	}
+
+	// Add methods to `Hash`.
+	Hash.prototype.clear = hashClear;
+	Hash.prototype['delete'] = hashDelete;
+	Hash.prototype.get = hashGet;
+	Hash.prototype.has = hashHas;
+	Hash.prototype.set = hashSet;
+
+	/**
+	 * Creates an list cache object.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function ListCache(entries) {
+	  var index = -1,
+	      length = entries ? entries.length : 0;
+
+	  this.clear();
+	  while (++index < length) {
+	    var entry = entries[index];
+	    this.set(entry[0], entry[1]);
+	  }
+	}
+
+	/**
+	 * Removes all key-value entries from the list cache.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf ListCache
+	 */
+	function listCacheClear() {
+	  this.__data__ = [];
+	}
+
+	/**
+	 * Removes `key` and its value from the list cache.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf ListCache
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function listCacheDelete(key) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  if (index < 0) {
+	    return false;
+	  }
+	  var lastIndex = data.length - 1;
+	  if (index == lastIndex) {
+	    data.pop();
+	  } else {
+	    splice.call(data, index, 1);
+	  }
+	  return true;
+	}
+
+	/**
+	 * Gets the list cache value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf ListCache
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function listCacheGet(key) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  return index < 0 ? undefined : data[index][1];
+	}
+
+	/**
+	 * Checks if a list cache value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf ListCache
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function listCacheHas(key) {
+	  return assocIndexOf(this.__data__, key) > -1;
+	}
+
+	/**
+	 * Sets the list cache `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf ListCache
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the list cache instance.
+	 */
+	function listCacheSet(key, value) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  if (index < 0) {
+	    data.push([key, value]);
+	  } else {
+	    data[index][1] = value;
+	  }
+	  return this;
+	}
+
+	// Add methods to `ListCache`.
+	ListCache.prototype.clear = listCacheClear;
+	ListCache.prototype['delete'] = listCacheDelete;
+	ListCache.prototype.get = listCacheGet;
+	ListCache.prototype.has = listCacheHas;
+	ListCache.prototype.set = listCacheSet;
+
+	/**
+	 * Creates a map cache object to store key-value pairs.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function MapCache(entries) {
+	  var index = -1,
+	      length = entries ? entries.length : 0;
+
+	  this.clear();
+	  while (++index < length) {
+	    var entry = entries[index];
+	    this.set(entry[0], entry[1]);
+	  }
+	}
+
+	/**
+	 * Removes all key-value entries from the map.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf MapCache
+	 */
+	function mapCacheClear() {
+	  this.__data__ = {
+	    'hash': new Hash,
+	    'map': new (Map || ListCache),
+	    'string': new Hash
+	  };
+	}
+
+	/**
+	 * Removes `key` and its value from the map.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf MapCache
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function mapCacheDelete(key) {
+	  return getMapData(this, key)['delete'](key);
+	}
+
+	/**
+	 * Gets the map value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf MapCache
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function mapCacheGet(key) {
+	  return getMapData(this, key).get(key);
+	}
+
+	/**
+	 * Checks if a map value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf MapCache
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function mapCacheHas(key) {
+	  return getMapData(this, key).has(key);
+	}
+
+	/**
+	 * Sets the map `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf MapCache
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the map cache instance.
+	 */
+	function mapCacheSet(key, value) {
+	  getMapData(this, key).set(key, value);
+	  return this;
+	}
+
+	// Add methods to `MapCache`.
+	MapCache.prototype.clear = mapCacheClear;
+	MapCache.prototype['delete'] = mapCacheDelete;
+	MapCache.prototype.get = mapCacheGet;
+	MapCache.prototype.has = mapCacheHas;
+	MapCache.prototype.set = mapCacheSet;
+
+	/**
+	 * Creates a stack cache object to store key-value pairs.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function Stack(entries) {
+	  this.__data__ = new ListCache(entries);
+	}
+
+	/**
+	 * Removes all key-value entries from the stack.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf Stack
+	 */
+	function stackClear() {
+	  this.__data__ = new ListCache;
+	}
+
+	/**
+	 * Removes `key` and its value from the stack.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf Stack
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function stackDelete(key) {
+	  return this.__data__['delete'](key);
+	}
+
+	/**
+	 * Gets the stack value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf Stack
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function stackGet(key) {
+	  return this.__data__.get(key);
+	}
+
+	/**
+	 * Checks if a stack value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf Stack
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function stackHas(key) {
+	  return this.__data__.has(key);
+	}
+
+	/**
+	 * Sets the stack `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf Stack
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the stack cache instance.
+	 */
+	function stackSet(key, value) {
+	  var cache = this.__data__;
+	  if (cache instanceof ListCache) {
+	    var pairs = cache.__data__;
+	    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+	      pairs.push([key, value]);
+	      return this;
+	    }
+	    cache = this.__data__ = new MapCache(pairs);
+	  }
+	  cache.set(key, value);
+	  return this;
+	}
+
+	// Add methods to `Stack`.
+	Stack.prototype.clear = stackClear;
+	Stack.prototype['delete'] = stackDelete;
+	Stack.prototype.get = stackGet;
+	Stack.prototype.has = stackHas;
+	Stack.prototype.set = stackSet;
+
+	/**
+	 * Creates an array of the enumerable property names of the array-like `value`.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @param {boolean} inherited Specify returning inherited property names.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function arrayLikeKeys(value, inherited) {
+	  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+	  // Safari 9 makes `arguments.length` enumerable in strict mode.
+	  var result = (isArray(value) || isArguments(value))
+	    ? baseTimes(value.length, String)
+	    : [];
+
+	  var length = result.length,
+	      skipIndexes = !!length;
+
+	  for (var key in value) {
+	    if ((hasOwnProperty.call(value, key)) &&
+	        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * Assigns `value` to `key` of `object` if the existing value is not equivalent
+	 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	 * for equality comparisons.
+	 *
+	 * @private
+	 * @param {Object} object The object to modify.
+	 * @param {string} key The key of the property to assign.
+	 * @param {*} value The value to assign.
+	 */
+	function assignValue(object, key, value) {
+	  var objValue = object[key];
+	  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+	      (value === undefined && !(key in object))) {
+	    object[key] = value;
+	  }
+	}
+
+	/**
+	 * Gets the index at which the `key` is found in `array` of key-value pairs.
+	 *
+	 * @private
+	 * @param {Array} array The array to inspect.
+	 * @param {*} key The key to search for.
+	 * @returns {number} Returns the index of the matched value, else `-1`.
+	 */
+	function assocIndexOf(array, key) {
+	  var length = array.length;
+	  while (length--) {
+	    if (eq(array[length][0], key)) {
+	      return length;
+	    }
+	  }
+	  return -1;
+	}
+
+	/**
+	 * The base implementation of `_.assign` without support for multiple sources
+	 * or `customizer` functions.
+	 *
+	 * @private
+	 * @param {Object} object The destination object.
+	 * @param {Object} source The source object.
+	 * @returns {Object} Returns `object`.
+	 */
+	function baseAssign(object, source) {
+	  return object && copyObject(source, keys(source), object);
+	}
+
+	/**
+	 * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+	 * traversed objects.
+	 *
+	 * @private
+	 * @param {*} value The value to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @param {boolean} [isFull] Specify a clone including symbols.
+	 * @param {Function} [customizer] The function to customize cloning.
+	 * @param {string} [key] The key of `value`.
+	 * @param {Object} [object] The parent object of `value`.
+	 * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+	 * @returns {*} Returns the cloned value.
+	 */
+	function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
+	  var result;
+	  if (customizer) {
+	    result = object ? customizer(value, key, object, stack) : customizer(value);
+	  }
+	  if (result !== undefined) {
+	    return result;
+	  }
+	  if (!isObject(value)) {
+	    return value;
+	  }
+	  var isArr = isArray(value);
+	  if (isArr) {
+	    result = initCloneArray(value);
+	    if (!isDeep) {
+	      return copyArray(value, result);
+	    }
+	  } else {
+	    var tag = getTag(value),
+	        isFunc = tag == funcTag || tag == genTag;
+
+	    if (isBuffer(value)) {
+	      return cloneBuffer(value, isDeep);
+	    }
+	    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+	      if (isHostObject(value)) {
+	        return object ? value : {};
+	      }
+	      result = initCloneObject(isFunc ? {} : value);
+	      if (!isDeep) {
+	        return copySymbols(value, baseAssign(result, value));
+	      }
+	    } else {
+	      if (!cloneableTags[tag]) {
+	        return object ? value : {};
+	      }
+	      result = initCloneByTag(value, tag, baseClone, isDeep);
+	    }
+	  }
+	  // Check for circular references and return its corresponding clone.
+	  stack || (stack = new Stack);
+	  var stacked = stack.get(value);
+	  if (stacked) {
+	    return stacked;
+	  }
+	  stack.set(value, result);
+
+	  if (!isArr) {
+	    var props = isFull ? getAllKeys(value) : keys(value);
+	  }
+	  arrayEach(props || value, function(subValue, key) {
+	    if (props) {
+	      key = subValue;
+	      subValue = value[key];
+	    }
+	    // Recursively populate clone (susceptible to call stack limits).
+	    assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
+	  });
+	  return result;
+	}
+
+	/**
+	 * The base implementation of `_.create` without support for assigning
+	 * properties to the created object.
+	 *
+	 * @private
+	 * @param {Object} prototype The object to inherit from.
+	 * @returns {Object} Returns the new object.
+	 */
+	function baseCreate(proto) {
+	  return isObject(proto) ? objectCreate(proto) : {};
+	}
+
+	/**
+	 * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+	 * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+	 * symbols of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @param {Function} keysFunc The function to get the keys of `object`.
+	 * @param {Function} symbolsFunc The function to get the symbols of `object`.
+	 * @returns {Array} Returns the array of property names and symbols.
+	 */
+	function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+	  var result = keysFunc(object);
+	  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+	}
+
+	/**
+	 * The base implementation of `getTag`.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @returns {string} Returns the `toStringTag`.
+	 */
+	function baseGetTag(value) {
+	  return objectToString.call(value);
+	}
+
+	/**
+	 * The base implementation of `_.isNative` without bad shim checks.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a native function,
+	 *  else `false`.
+	 */
+	function baseIsNative(value) {
+	  if (!isObject(value) || isMasked(value)) {
+	    return false;
+	  }
+	  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+	  return pattern.test(toSource(value));
+	}
+
+	/**
+	 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function baseKeys(object) {
+	  if (!isPrototype(object)) {
+	    return nativeKeys(object);
+	  }
+	  var result = [];
+	  for (var key in Object(object)) {
+	    if (hasOwnProperty.call(object, key) && key != 'constructor') {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * Creates a clone of  `buffer`.
+	 *
+	 * @private
+	 * @param {Buffer} buffer The buffer to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Buffer} Returns the cloned buffer.
+	 */
+	function cloneBuffer(buffer, isDeep) {
+	  if (isDeep) {
+	    return buffer.slice();
+	  }
+	  var result = new buffer.constructor(buffer.length);
+	  buffer.copy(result);
+	  return result;
+	}
+
+	/**
+	 * Creates a clone of `arrayBuffer`.
+	 *
+	 * @private
+	 * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+	 * @returns {ArrayBuffer} Returns the cloned array buffer.
+	 */
+	function cloneArrayBuffer(arrayBuffer) {
+	  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+	  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+	  return result;
+	}
+
+	/**
+	 * Creates a clone of `dataView`.
+	 *
+	 * @private
+	 * @param {Object} dataView The data view to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned data view.
+	 */
+	function cloneDataView(dataView, isDeep) {
+	  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+	  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+	}
+
+	/**
+	 * Creates a clone of `map`.
+	 *
+	 * @private
+	 * @param {Object} map The map to clone.
+	 * @param {Function} cloneFunc The function to clone values.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned map.
+	 */
+	function cloneMap(map, isDeep, cloneFunc) {
+	  var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);
+	  return arrayReduce(array, addMapEntry, new map.constructor);
+	}
+
+	/**
+	 * Creates a clone of `regexp`.
+	 *
+	 * @private
+	 * @param {Object} regexp The regexp to clone.
+	 * @returns {Object} Returns the cloned regexp.
+	 */
+	function cloneRegExp(regexp) {
+	  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+	  result.lastIndex = regexp.lastIndex;
+	  return result;
+	}
+
+	/**
+	 * Creates a clone of `set`.
+	 *
+	 * @private
+	 * @param {Object} set The set to clone.
+	 * @param {Function} cloneFunc The function to clone values.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned set.
+	 */
+	function cloneSet(set, isDeep, cloneFunc) {
+	  var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);
+	  return arrayReduce(array, addSetEntry, new set.constructor);
+	}
+
+	/**
+	 * Creates a clone of the `symbol` object.
+	 *
+	 * @private
+	 * @param {Object} symbol The symbol object to clone.
+	 * @returns {Object} Returns the cloned symbol object.
+	 */
+	function cloneSymbol(symbol) {
+	  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+	}
+
+	/**
+	 * Creates a clone of `typedArray`.
+	 *
+	 * @private
+	 * @param {Object} typedArray The typed array to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned typed array.
+	 */
+	function cloneTypedArray(typedArray, isDeep) {
+	  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+	  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+	}
+
+	/**
+	 * Copies the values of `source` to `array`.
+	 *
+	 * @private
+	 * @param {Array} source The array to copy values from.
+	 * @param {Array} [array=[]] The array to copy values to.
+	 * @returns {Array} Returns `array`.
+	 */
+	function copyArray(source, array) {
+	  var index = -1,
+	      length = source.length;
+
+	  array || (array = Array(length));
+	  while (++index < length) {
+	    array[index] = source[index];
+	  }
+	  return array;
+	}
+
+	/**
+	 * Copies properties of `source` to `object`.
+	 *
+	 * @private
+	 * @param {Object} source The object to copy properties from.
+	 * @param {Array} props The property identifiers to copy.
+	 * @param {Object} [object={}] The object to copy properties to.
+	 * @param {Function} [customizer] The function to customize copied values.
+	 * @returns {Object} Returns `object`.
+	 */
+	function copyObject(source, props, object, customizer) {
+	  object || (object = {});
+
+	  var index = -1,
+	      length = props.length;
+
+	  while (++index < length) {
+	    var key = props[index];
+
+	    var newValue = undefined;
+
+	    assignValue(object, key, newValue === undefined ? source[key] : newValue);
+	  }
+	  return object;
+	}
+
+	/**
+	 * Copies own symbol properties of `source` to `object`.
+	 *
+	 * @private
+	 * @param {Object} source The object to copy symbols from.
+	 * @param {Object} [object={}] The object to copy symbols to.
+	 * @returns {Object} Returns `object`.
+	 */
+	function copySymbols(source, object) {
+	  return copyObject(source, getSymbols(source), object);
+	}
+
+	/**
+	 * Creates an array of own enumerable property names and symbols of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names and symbols.
+	 */
+	function getAllKeys(object) {
+	  return baseGetAllKeys(object, keys, getSymbols);
+	}
+
+	/**
+	 * Gets the data for `map`.
+	 *
+	 * @private
+	 * @param {Object} map The map to query.
+	 * @param {string} key The reference key.
+	 * @returns {*} Returns the map data.
+	 */
+	function getMapData(map, key) {
+	  var data = map.__data__;
+	  return isKeyable(key)
+	    ? data[typeof key == 'string' ? 'string' : 'hash']
+	    : data.map;
+	}
+
+	/**
+	 * Gets the native function at `key` of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @param {string} key The key of the method to get.
+	 * @returns {*} Returns the function if it's native, else `undefined`.
+	 */
+	function getNative(object, key) {
+	  var value = getValue(object, key);
+	  return baseIsNative(value) ? value : undefined;
+	}
+
+	/**
+	 * Creates an array of the own enumerable symbol properties of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of symbols.
+	 */
+	var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
+
+	/**
+	 * Gets the `toStringTag` of `value`.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @returns {string} Returns the `toStringTag`.
+	 */
+	var getTag = baseGetTag;
+
+	// Fallback for data views, maps, sets, and weak maps in IE 11,
+	// for data views in Edge < 14, and promises in Node.js.
+	if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+	    (Map && getTag(new Map) != mapTag) ||
+	    (Promise && getTag(Promise.resolve()) != promiseTag) ||
+	    (Set && getTag(new Set) != setTag) ||
+	    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+	  getTag = function(value) {
+	    var result = objectToString.call(value),
+	        Ctor = result == objectTag ? value.constructor : undefined,
+	        ctorString = Ctor ? toSource(Ctor) : undefined;
+
+	    if (ctorString) {
+	      switch (ctorString) {
+	        case dataViewCtorString: return dataViewTag;
+	        case mapCtorString: return mapTag;
+	        case promiseCtorString: return promiseTag;
+	        case setCtorString: return setTag;
+	        case weakMapCtorString: return weakMapTag;
+	      }
+	    }
+	    return result;
+	  };
+	}
+
+	/**
+	 * Initializes an array clone.
+	 *
+	 * @private
+	 * @param {Array} array The array to clone.
+	 * @returns {Array} Returns the initialized clone.
+	 */
+	function initCloneArray(array) {
+	  var length = array.length,
+	      result = array.constructor(length);
+
+	  // Add properties assigned by `RegExp#exec`.
+	  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
+	    result.index = array.index;
+	    result.input = array.input;
+	  }
+	  return result;
+	}
+
+	/**
+	 * Initializes an object clone.
+	 *
+	 * @private
+	 * @param {Object} object The object to clone.
+	 * @returns {Object} Returns the initialized clone.
+	 */
+	function initCloneObject(object) {
+	  return (typeof object.constructor == 'function' && !isPrototype(object))
+	    ? baseCreate(getPrototype(object))
+	    : {};
+	}
+
+	/**
+	 * Initializes an object clone based on its `toStringTag`.
+	 *
+	 * **Note:** This function only supports cloning values with tags of
+	 * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+	 *
+	 * @private
+	 * @param {Object} object The object to clone.
+	 * @param {string} tag The `toStringTag` of the object to clone.
+	 * @param {Function} cloneFunc The function to clone values.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the initialized clone.
+	 */
+	function initCloneByTag(object, tag, cloneFunc, isDeep) {
+	  var Ctor = object.constructor;
+	  switch (tag) {
+	    case arrayBufferTag:
+	      return cloneArrayBuffer(object);
+
+	    case boolTag:
+	    case dateTag:
+	      return new Ctor(+object);
+
+	    case dataViewTag:
+	      return cloneDataView(object, isDeep);
+
+	    case float32Tag: case float64Tag:
+	    case int8Tag: case int16Tag: case int32Tag:
+	    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
+	      return cloneTypedArray(object, isDeep);
+
+	    case mapTag:
+	      return cloneMap(object, isDeep, cloneFunc);
+
+	    case numberTag:
+	    case stringTag:
+	      return new Ctor(object);
+
+	    case regexpTag:
+	      return cloneRegExp(object);
+
+	    case setTag:
+	      return cloneSet(object, isDeep, cloneFunc);
+
+	    case symbolTag:
+	      return cloneSymbol(object);
+	  }
+	}
+
+	/**
+	 * Checks if `value` is a valid array-like index.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+	 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+	 */
+	function isIndex(value, length) {
+	  length = length == null ? MAX_SAFE_INTEGER : length;
+	  return !!length &&
+	    (typeof value == 'number' || reIsUint.test(value)) &&
+	    (value > -1 && value % 1 == 0 && value < length);
+	}
+
+	/**
+	 * Checks if `value` is suitable for use as unique object key.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+	 */
+	function isKeyable(value) {
+	  var type = typeof value;
+	  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+	    ? (value !== '__proto__')
+	    : (value === null);
+	}
+
+	/**
+	 * Checks if `func` has its source masked.
+	 *
+	 * @private
+	 * @param {Function} func The function to check.
+	 * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+	 */
+	function isMasked(func) {
+	  return !!maskSrcKey && (maskSrcKey in func);
+	}
+
+	/**
+	 * Checks if `value` is likely a prototype object.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+	 */
+	function isPrototype(value) {
+	  var Ctor = value && value.constructor,
+	      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+	  return value === proto;
+	}
+
+	/**
+	 * Converts `func` to its source code.
+	 *
+	 * @private
+	 * @param {Function} func The function to process.
+	 * @returns {string} Returns the source code.
+	 */
+	function toSource(func) {
+	  if (func != null) {
+	    try {
+	      return funcToString.call(func);
+	    } catch (e) {}
+	    try {
+	      return (func + '');
+	    } catch (e) {}
+	  }
+	  return '';
+	}
+
+	/**
+	 * This method is like `_.clone` except that it recursively clones `value`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 1.0.0
+	 * @category Lang
+	 * @param {*} value The value to recursively clone.
+	 * @returns {*} Returns the deep cloned value.
+	 * @see _.clone
+	 * @example
+	 *
+	 * var objects = [{ 'a': 1 }, { 'b': 2 }];
+	 *
+	 * var deep = _.cloneDeep(objects);
+	 * console.log(deep[0] === objects[0]);
+	 * // => false
+	 */
+	function cloneDeep(value) {
+	  return baseClone(value, true, true);
+	}
+
+	/**
+	 * Performs a
+	 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	 * comparison between two values to determine if they are equivalent.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to compare.
+	 * @param {*} other The other value to compare.
+	 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	 * @example
+	 *
+	 * var object = { 'a': 1 };
+	 * var other = { 'a': 1 };
+	 *
+	 * _.eq(object, object);
+	 * // => true
+	 *
+	 * _.eq(object, other);
+	 * // => false
+	 *
+	 * _.eq('a', 'a');
+	 * // => true
+	 *
+	 * _.eq('a', Object('a'));
+	 * // => false
+	 *
+	 * _.eq(NaN, NaN);
+	 * // => true
+	 */
+	function eq(value, other) {
+	  return value === other || (value !== value && other !== other);
+	}
+
+	/**
+	 * Checks if `value` is likely an `arguments` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	 *  else `false`.
+	 * @example
+	 *
+	 * _.isArguments(function() { return arguments; }());
+	 * // => true
+	 *
+	 * _.isArguments([1, 2, 3]);
+	 * // => false
+	 */
+	function isArguments(value) {
+	  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+	  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
+	    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
+	}
+
+	/**
+	 * Checks if `value` is classified as an `Array` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+	 * @example
+	 *
+	 * _.isArray([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isArray(document.body.children);
+	 * // => false
+	 *
+	 * _.isArray('abc');
+	 * // => false
+	 *
+	 * _.isArray(_.noop);
+	 * // => false
+	 */
+	var isArray = Array.isArray;
+
+	/**
+	 * Checks if `value` is array-like. A value is considered array-like if it's
+	 * not a function and has a `value.length` that's an integer greater than or
+	 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+	 * @example
+	 *
+	 * _.isArrayLike([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isArrayLike(document.body.children);
+	 * // => true
+	 *
+	 * _.isArrayLike('abc');
+	 * // => true
+	 *
+	 * _.isArrayLike(_.noop);
+	 * // => false
+	 */
+	function isArrayLike(value) {
+	  return value != null && isLength(value.length) && !isFunction(value);
+	}
+
+	/**
+	 * This method is like `_.isArrayLike` except that it also checks if `value`
+	 * is an object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an array-like object,
+	 *  else `false`.
+	 * @example
+	 *
+	 * _.isArrayLikeObject([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isArrayLikeObject(document.body.children);
+	 * // => true
+	 *
+	 * _.isArrayLikeObject('abc');
+	 * // => false
+	 *
+	 * _.isArrayLikeObject(_.noop);
+	 * // => false
+	 */
+	function isArrayLikeObject(value) {
+	  return isObjectLike(value) && isArrayLike(value);
+	}
+
+	/**
+	 * Checks if `value` is a buffer.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.3.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+	 * @example
+	 *
+	 * _.isBuffer(new Buffer(2));
+	 * // => true
+	 *
+	 * _.isBuffer(new Uint8Array(2));
+	 * // => false
+	 */
+	var isBuffer = nativeIsBuffer || stubFalse;
+
+	/**
+	 * Checks if `value` is classified as a `Function` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	 * @example
+	 *
+	 * _.isFunction(_);
+	 * // => true
+	 *
+	 * _.isFunction(/abc/);
+	 * // => false
+	 */
+	function isFunction(value) {
+	  // The use of `Object#toString` avoids issues with the `typeof` operator
+	  // in Safari 8-9 which returns 'object' for typed array and other constructors.
+	  var tag = isObject(value) ? objectToString.call(value) : '';
+	  return tag == funcTag || tag == genTag;
+	}
+
+	/**
+	 * Checks if `value` is a valid array-like length.
+	 *
+	 * **Note:** This method is loosely based on
+	 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+	 * @example
+	 *
+	 * _.isLength(3);
+	 * // => true
+	 *
+	 * _.isLength(Number.MIN_VALUE);
+	 * // => false
+	 *
+	 * _.isLength(Infinity);
+	 * // => false
+	 *
+	 * _.isLength('3');
+	 * // => false
+	 */
+	function isLength(value) {
+	  return typeof value == 'number' &&
+	    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+	}
+
+	/**
+	 * Checks if `value` is the
+	 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	 * @example
+	 *
+	 * _.isObject({});
+	 * // => true
+	 *
+	 * _.isObject([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isObject(_.noop);
+	 * // => true
+	 *
+	 * _.isObject(null);
+	 * // => false
+	 */
+	function isObject(value) {
+	  var type = typeof value;
+	  return !!value && (type == 'object' || type == 'function');
+	}
+
+	/**
+	 * Checks if `value` is object-like. A value is object-like if it's not `null`
+	 * and has a `typeof` result of "object".
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	 * @example
+	 *
+	 * _.isObjectLike({});
+	 * // => true
+	 *
+	 * _.isObjectLike([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isObjectLike(_.noop);
+	 * // => false
+	 *
+	 * _.isObjectLike(null);
+	 * // => false
+	 */
+	function isObjectLike(value) {
+	  return !!value && typeof value == 'object';
+	}
+
+	/**
+	 * Creates an array of the own enumerable property names of `object`.
+	 *
+	 * **Note:** Non-object values are coerced to objects. See the
+	 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+	 * for more details.
+	 *
+	 * @static
+	 * @since 0.1.0
+	 * @memberOf _
+	 * @category Object
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 * @example
+	 *
+	 * function Foo() {
+	 *   this.a = 1;
+	 *   this.b = 2;
+	 * }
+	 *
+	 * Foo.prototype.c = 3;
+	 *
+	 * _.keys(new Foo);
+	 * // => ['a', 'b'] (iteration order is not guaranteed)
+	 *
+	 * _.keys('hi');
+	 * // => ['0', '1']
+	 */
+	function keys(object) {
+	  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+	}
+
+	/**
+	 * This method returns a new empty array.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.13.0
+	 * @category Util
+	 * @returns {Array} Returns the new empty array.
+	 * @example
+	 *
+	 * var arrays = _.times(2, _.stubArray);
+	 *
+	 * console.log(arrays);
+	 * // => [[], []]
+	 *
+	 * console.log(arrays[0] === arrays[1]);
+	 * // => false
+	 */
+	function stubArray() {
+	  return [];
+	}
+
+	/**
+	 * This method returns `false`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.13.0
+	 * @category Util
+	 * @returns {boolean} Returns `false`.
+	 * @example
+	 *
+	 * _.times(2, _.stubFalse);
+	 * // => [false, false]
+	 */
+	function stubFalse() {
+	  return false;
+	}
+
+	module.exports = cloneDeep; 
+} (lodash_clonedeep, lodash_clonedeep.exports));
+
+var lodash_clonedeepExports = lodash_clonedeep.exports;
+var cloneDeep = /*@__PURE__*/getDefaultExportFromCjs$1(lodash_clonedeepExports);
+
+/**
+ * Perform a deep clone of the given value.
+ *
+ * This function supports cloning:
+ *
+ * - Primitive types such as booleans, numbers and strings
+ * - Arrays and objects
+ * - Classes
+ * - `Date`,
+ * - `Map`,
+ * - `RegExp`
+ * - `Set`
+ * - `Symbol`
+ *
+ * The following values are NOT cloned:
+ *
+ * - `Error` (and subclasses) - Cloned value will reference the same Error instance.
+ * - DOM `Node` (and subclasses) - Cloned value will return the same DOM reference.
+ * - `Function` (and arrow functions) - Cloned value will be an empty object `{}`
+ *
+ * @public
+ * @param value - The value to recursively clone.
+ * @returns Returns the deep cloned value.
+ */
+function deepClone(value) {
+    return cloneDeep(value);
+}
+
+/**
+ * An error indicating that a mandatory value is not set.
+ *
+ * @public
+ */
+class MissingValueError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, MissingValueError.prototype);
+    }
+}
+/**
+ * Assert that a value is set and throw a {@link MissingValueError} if it is not,
+ * i.e., both null and undefined values will throw an error. This can be nice to
+ * use when transforming data between view model and rest api model.
+ *
+ * @public
+ * @param value - the value asserted to be set.
+ * @param message - an optional exception message to use if the check fails.
+ * @returns the value unambiguously defined.
+ * @throws {@link MissingValueError} if value is not set.
+ */
+function ensureSet(value, message = "") {
+    if (!isSet(value)) {
+        throw new MissingValueError(message);
+    }
+    return value;
+}
+
+/**
+ * Takes an optionally nested textobject structure and convert to a flat
+ * structure. Nested keys are joined with a dot ".". Deep nesting is supported.
+ *
+ * Given the following:
+ * ```
+ * {
+ *   "foo": {
+ *     "bar": "text"
+ *   }
+ * }
+ * ```
+ *
+ * It would produce the following output:
+ * ```
+ * {
+ *   "foo.bar": "text"
+ * }
+ * ```
+ *
+ * If the src object is already flat the output will be the same.
+ *
+ * @public
+ * @param src - Source data
+ * @param destination - Destination to write temporary result to.
+ * @param prefix - If set this is prefixed to all keys.
+ */
+function flatten(src, destination, prefix = "") {
+    destination = destination || {};
+    return Object.entries(src).reduce((result, [key, data]) => {
+        const nestedKey = `${prefix}${key}`;
+        if (typeof data === "string") {
+            result[nestedKey] = data;
+        }
+        else {
+            flatten(data, result, `${nestedKey}.`);
+        }
+        return result;
+    }, destination);
+}
+
+/**
+ * Takes a date string in any of the supported formats and normalizes it for
+ * usage with `FDate` (ISO-8601).
+ *
+ * Handles:
+ *
+ * - `YYYY-MM-DD`
+ * - `YYYY/MM/DD`
+ * - `YYYYMMDD`
+ *
+ * @internal
+ * @param value - Date string to normalize.
+ * @returns Normalized date string (ISO-8601) or undefined if it doesnt match one of the
+ * supported formats.
+ */
+function normalizeDateFormat(value) {
+    const supportedFormats = [
+        /* yyyy-mm-dd */
+        /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/,
+        /* yyyymmdd */
+        /^(?<year>\d{4})(?<month>\d{2})(?<day>\d{2})$/,
+        /* yyyy-mm-dd */
+        /^(?<year>\d{4})\/(?<month>\d{2})\/(?<day>\d{2})$/,
+    ];
+    const match = supportedFormats
+        .map((pattern) => value.match(pattern))
+        .find(Boolean);
+    if (!match || !match.groups) {
+        return undefined;
+    }
+    const { year, month, day } = match.groups;
+    return `${year}-${month}-${day}`;
+}
+
+/**
+ * Takes a string containing only numbers and checks that the checksum is correct
+ * according to the Luhn Algorithm.
+ *
+ * @public
+ * @param inputString - A string containing only numbers
+ */
+function testLuhnChecksum(inputString) {
+    let sum = 0;
+    if (/^[0-9]+$/.test(inputString) === false) {
+        throw new Error("Luhn Checksum test only works on strings containing numbers");
+    }
+    inputString
+        .split("")
+        .reverse()
+        .forEach((numChar, index) => {
+        const digit = parseInt(numChar, 10) * ((index + 1) % 2 === 0 ? 2 : 1);
+        sum += digit >= 10 ? digit - 9 : digit;
+    });
+    return sum % 10 === 0;
+}
+
+/**
+ * @public
+ */
+function validChecksum(value) {
+    const yymmddxxxx = value.slice(2).replace(/-/g, "");
+    return testLuhnChecksum(yymmddxxxx);
+}
+
+const TWELVE_HOURS = 12 * 60 * 60;
+/**
+ * @public
+ */
+function setCookie(options) {
+    const shouldKeepTheExistingCookie = options.keepAnyExistingCookie && findCookie(options.name);
+    if (shouldKeepTheExistingCookie) {
+        return;
+    }
+    let cookieString = `${options.name}=${encodeURIComponent(options.value)}; path=/;`;
+    const timeLimitSeconds = options.timeLimitMillis
+        ? Math.round(options.timeLimitMillis / 1000)
+        : options.timeLimitSeconds;
+    const timeout = timeLimitSeconds ?? TWELVE_HOURS;
+    cookieString += `max-age=${timeout};`;
+    document.cookie = cookieString;
+}
+/**
+ * @public
+ */
+function deleteCookie(name) {
+    document.cookie = `${name}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT;`;
+}
+/**
+ * @public
+ */
+function findCookie(name) {
+    /* handle when document or cookie does not exist, e.g. when DOM isn't
+     * present */
+    if (!document?.cookie) {
+        return undefined;
+    }
+    const cookieKeyValueStrings = document.cookie.split(";");
+    for (const cookie of cookieKeyValueStrings) {
+        const [foundCookieName, foundCookieValue] = cookie.split("=", 2);
+        if (name === foundCookieName.trim()) {
+            return foundCookieValue
+                ? decodeURIComponent(foundCookieValue)
+                : undefined;
+        }
+    }
+    return undefined;
+}
+
+const BANK_ACCOUNT_NUMBER_REGEXP = /^\d{3,16}$/;
+const BANK_ACCOUNT_NUMBER_TRIM_REGEXP = /[- .,]+/g;
+/**
+ * @public
+ */
+function parseBankAccountNumber(value) {
+    if (isEmpty(value)) {
+        return undefined;
+    }
+    // remove hyphen, blank space, period, comma
+    const trimmedValue = value.replace(BANK_ACCOUNT_NUMBER_TRIM_REGEXP, "");
+    return BANK_ACCOUNT_NUMBER_REGEXP.test(trimmedValue)
+        ? trimmedValue
+        : undefined;
+}
+
+const BANKGIRO_REGEXP_HYPHEN = /^(\d{3,4})[-]?(\d{4})$/;
+/**
+ * @public
+ */
+function parseBankgiro(value) {
+    if (isEmpty(value)) {
+        return undefined;
+    }
+    const match = value.match(BANKGIRO_REGEXP_HYPHEN);
+    if (!match) {
+        return undefined;
+    }
+    if (!testLuhnChecksum(`${match[1]}${match[2]}`)) {
+        return undefined;
+    }
+    return `${match[1]}-${match[2]}`;
+}
+
+const CLEARINGNUMBER_REGEXP = /^\d{4}([-\s]?\d)?$/;
+/**
+ * @public
+ */
+function parseClearingNumber(value) {
+    if (isEmpty(value)) {
+        return undefined;
+    }
+    if (!CLEARINGNUMBER_REGEXP.test(value)) {
+        return undefined;
+    }
+    // add hyphen between number 4 & 5
+    return value.length === 5
+        ? `${value.substring(0, 4)}-${value.substring(4, 5)}`
+        : value;
+}
+/**
+ * @public
+ */
+function formatClearingNumberForBackend(value) {
+    // remove the 5th number
+    return value.substring(0, 4);
+}
+
+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 dayjs_min = {exports: {}};
+
+(function (module, exports) {
+	!function(t,e){module.exports=e();}(commonjsGlobal,(function(){var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",c="month",f="quarter",h="year",d="date",l="Invalid Date",$=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function(t){var e=["th","st","nd","rd"],n=t%100;return "["+t+(e[(n-20)%10]||e[n]||e[0])+"]"}},m=function(t,e,n){var r=String(t);return !r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return (e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()<n.date())return -t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,c),s=n-i<0,u=e.clone().add(r+(s?-1:1),c);return +(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return {M:c,y:h,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:f}[t]||String(t||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},g="en",D={};D[g]=M;var p="$isDayjsObject",S=function(t){return t instanceof _||!(!t||!t[p])},w=function t(e,n,r){var i;if(!e)return g;if("string"==typeof e){var s=e.toLowerCase();D[s]&&(i=s),n&&(D[s]=n,i=s);var u=e.split("-");if(!i&&u.length>1)return t(u[0])}else {var a=e.name;D[a]=e,i=a;}return !r&&i&&(g=i),i||!r&&g},O=function(t,e){if(S(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},b=v;b.l=w,b.i=S,b.w=function(t,e){return O(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=w(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[p]=!0;}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(b.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.init();},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds();},m.$utils=function(){return b},m.isValid=function(){return !(this.$d.toString()===l)},m.isSame=function(t,e){var n=O(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return O(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<O(t)},m.$g=function(t,e,n){return b.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!b.u(e)||e,f=b.p(t),l=function(t,e){var i=b.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},$=function(t,e){return b.w(n.toDate()[t].apply(n.toDate("s"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,v="set"+(this.$u?"UTC":"");switch(f){case h:return r?l(1,0):l(31,11);case c:return r?l(1,M):l(0,M+1);case o:var g=this.$locale().weekStart||0,D=(y<g?y+7:y)-g;return l(r?m-D:m+(6-D),M);case a:case d:return $(v+"Hours",0);case u:return $(v+"Minutes",1);case s:return $(v+"Seconds",2);case i:return $(v+"Milliseconds",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=b.p(t),f="set"+(this.$u?"UTC":""),l=(n={},n[a]=f+"Date",n[d]=f+"Date",n[c]=f+"Month",n[h]=f+"FullYear",n[u]=f+"Hours",n[s]=f+"Minutes",n[i]=f+"Seconds",n[r]=f+"Milliseconds",n)[o],$=o===a?this.$D+(e-this.$W):e;if(o===c||o===h){var y=this.clone().set(d,1);y.$d[l]($),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d;}else l&&this.$d[l]($);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[b.p(t)]()},m.add=function(r,f){var d,l=this;r=Number(r);var $=b.p(f),y=function(t){var e=O(l);return b.w(e.date(e.date()+Math.round(t*r)),l)};if($===c)return this.set(c,this.$M+r);if($===h)return this.set(h,this.$y+r);if($===a)return y(1);if($===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[$]||1,m=this.$d.getTime()+r*M;return b.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||l;var r=t||"YYYY-MM-DDTHH:mm:ssZ",i=b.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,c=n.months,f=n.meridiem,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].slice(0,s)},d=function(t){return b.s(s%12||12,t,"0")},$=f||function(t,e,n){var r=t<12?"AM":"PM";return n?r.toLowerCase():r};return r.replace(y,(function(t,r){return r||function(t){switch(t){case"YY":return String(e.$y).slice(-2);case"YYYY":return b.s(e.$y,4,"0");case"M":return a+1;case"MM":return b.s(a+1,2,"0");case"MMM":return h(n.monthsShort,a,c,3);case"MMMM":return h(c,a);case"D":return e.$D;case"DD":return b.s(e.$D,2,"0");case"d":return String(e.$W);case"dd":return h(n.weekdaysMin,e.$W,o,2);case"ddd":return h(n.weekdaysShort,e.$W,o,3);case"dddd":return o[e.$W];case"H":return String(s);case"HH":return b.s(s,2,"0");case"h":return d(1);case"hh":return d(2);case"a":return $(s,u,!0);case"A":return $(s,u,!1);case"m":return String(u);case"mm":return b.s(u,2,"0");case"s":return String(e.$s);case"ss":return b.s(e.$s,2,"0");case"SSS":return b.s(e.$ms,3,"0");case"Z":return i}return null}(t)||i.replace(":","")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,l){var $,y=this,M=b.p(d),m=O(r),v=(m.utcOffset()-this.utcOffset())*e,g=this-m,D=function(){return b.m(y,m)};switch(M){case h:$=D()/12;break;case c:$=D();break;case f:$=D()/3;break;case o:$=(g-v)/6048e5;break;case a:$=(g-v)/864e5;break;case u:$=g/n;break;case s:$=g/e;break;case i:$=g/t;break;default:$=g;}return l?$:b.a($)},m.daysInMonth=function(){return this.endOf(c).$D},m.$locale=function(){return D[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=w(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return b.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),k=_.prototype;return O.prototype=k,[["$ms",r],["$s",i],["$m",s],["$H",u],["$W",a],["$M",c],["$y",h],["$D",d]].forEach((function(t){k[t[1]]=function(e){return this.$g(e,t[0],t[1])};})),O.extend=function(t,e){return t.$i||(t(e,_,O),t.$i=!0),O},O.locale=w,O.isDayjs=S,O.unix=function(t){return O(1e3*t)},O.en=D[g],O.Ls=D,O.p={},O})); 
+} (dayjs_min));
+
+var dayjs_minExports = dayjs_min.exports;
+var dayjs = /*@__PURE__*/getDefaultExportFromCjs(dayjs_minExports);
+
+var sv = {exports: {}};
+
+(function (module, exports) {
+	!function(e,t){module.exports=t(dayjs_minExports);}(commonjsGlobal,(function(e){function t(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var a=t(e),d={name:"sv",weekdays:"söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag".split("_"),weekdaysShort:"sön_mån_tis_ons_tor_fre_lör".split("_"),weekdaysMin:"sö_må_ti_on_to_fr_lö".split("_"),months:"januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekStart:1,yearStart:4,ordinal:function(e){var t=e%10;return "["+e+(1===t||2===t?"a":"e")+"]"},formats:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [kl.] HH:mm",LLLL:"dddd D MMMM YYYY [kl.] HH:mm",lll:"D MMM YYYY HH:mm",llll:"ddd D MMM YYYY HH:mm"},relativeTime:{future:"om %s",past:"för %s sedan",s:"några sekunder",m:"en minut",mm:"%d minuter",h:"en timme",hh:"%d timmar",d:"en dag",dd:"%d dagar",M:"en månad",MM:"%d månader",y:"ett år",yy:"%d år"}};return a.default.locale(d,null,!0),d})); 
+} (sv));
+
+var weekOfYear$1 = {exports: {}};
+
+(function (module, exports) {
+	!function(e,t){module.exports=t();}(commonjsGlobal,(function(){var e="week",t="year";return function(i,n,r){var f=n.prototype;f.week=function(i){if(void 0===i&&(i=null),null!==i)return this.add(7*(i-this.week()),"day");var n=this.$locale().yearStart||1;if(11===this.month()&&this.date()>25){var f=r(this).startOf(t).add(1,t).date(n),s=r(this).endOf(e);if(f.isBefore(s))return 1}var a=r(this).startOf(t).date(n).startOf(e).subtract(1,"millisecond"),o=this.diff(a,e,!0);return o<0?r(this).startOf("week").week():Math.ceil(o)},f.weeks=function(e){return void 0===e&&(e=null),this.week(e)};}})); 
+} (weekOfYear$1));
+
+var weekOfYearExports = weekOfYear$1.exports;
+var weekOfYear = /*@__PURE__*/getDefaultExportFromCjs(weekOfYearExports);
+
+dayjs.extend(weekOfYear);
+
+/**
+ * What format to use when formatting dates.
+ *
+ * @public
+ */
+var DateFormat;
+(function (DateFormat) {
+    /**
+     * Format with weekday, day, month, year as a human-readable string.
+     *
+     * "onsdag 4 maj 2022"
+     */
+    DateFormat["FULL"] = "full";
+    /**
+     * Format with day, month, year as a human-readable string.
+     *
+     * "4 maj 2022"
+     */
+    DateFormat["LONG"] = "long";
+    /**
+     * Format according to ISO 8601 format.
+     *
+     * "2022-05-04"
+     */
+    DateFormat["ISO8601"] = "iso-8601";
+    /**
+     * Format YYYYMMDD
+     *
+     * "20220504"
+     */
+    DateFormat["YYYYMMDD"] = "YYYYMMDD";
+})(DateFormat || (DateFormat = {}));
+
+/**
+ * What locale to use when formatting days.
+ *
+ * @public
+ */
+var Locale;
+(function (Locale) {
+    Locale["SWEDISH"] = "sv";
+    Locale["ENGLISH"] = "en";
+})(Locale || (Locale = {}));
+function getDefaultLocale() {
+    return Locale.SWEDISH;
+}
+let _locale = getDefaultLocale();
+/**
+ * Get current locale.
+ *
+ * Swedish locale is default.
+ *
+ * @public
+ */
+function getLocale() {
+    return _locale;
+}
+
+/**
+ * Days in a week.
+ * MONDAY(1) to SUNDAY(7)
+ *
+ * @public
+ */
+var Weekday;
+(function (Weekday) {
+    Weekday[Weekday["MONDAY"] = 1] = "MONDAY";
+    Weekday[Weekday["TUESDAY"] = 2] = "TUESDAY";
+    Weekday[Weekday["WEDNESDAY"] = 3] = "WEDNESDAY";
+    Weekday[Weekday["THURSDAY"] = 4] = "THURSDAY";
+    Weekday[Weekday["FRIDAY"] = 5] = "FRIDAY";
+    Weekday[Weekday["SATURDAY"] = 6] = "SATURDAY";
+    Weekday[Weekday["SUNDAY"] = 7] = "SUNDAY";
+})(Weekday || (Weekday = {}));
+
+({
+    [Locale.SWEDISH]: [
+        {
+            weekday: Weekday.MONDAY,
+            name: "måndag",
+            shortName: "mån",
+        },
+        {
+            weekday: Weekday.TUESDAY,
+            name: "tisdag",
+            shortName: "tis",
+        },
+        {
+            weekday: Weekday.WEDNESDAY,
+            name: "onsdag",
+            shortName: "ons",
+        },
+        {
+            weekday: Weekday.THURSDAY,
+            name: "torsdag",
+            shortName: "tor",
+        },
+        {
+            weekday: Weekday.FRIDAY,
+            name: "fredag",
+            shortName: "fre",
+        },
+        {
+            weekday: Weekday.SATURDAY,
+            name: "lördag",
+            shortName: "lör",
+        },
+        {
+            weekday: Weekday.SUNDAY,
+            name: "söndag",
+            shortName: "sön",
+        },
+    ],
+    [Locale.ENGLISH]: [
+        {
+            weekday: Weekday.MONDAY,
+            name: "Monday",
+            shortName: "Mon",
+        },
+        {
+            weekday: Weekday.TUESDAY,
+            name: "Tuesday",
+            shortName: "Tue",
+        },
+        {
+            weekday: Weekday.WEDNESDAY,
+            name: "Wednesday",
+            shortName: "Wed",
+        },
+        {
+            weekday: Weekday.THURSDAY,
+            name: "Thursday",
+            shortName: "Thu",
+        },
+        {
+            weekday: Weekday.FRIDAY,
+            name: "Friday",
+            shortName: "Fri",
+        },
+        {
+            weekday: Weekday.SATURDAY,
+            name: "Saturday",
+            shortName: "Sat",
+        },
+        {
+            weekday: Weekday.SUNDAY,
+            name: "Sunday",
+            shortName: "Sun",
+        },
+    ],
+});
+
+const ISO8601_YYYY_MM_DD = "YYYY-MM-DD";
+const formatter = {
+    [Locale.SWEDISH]: {
+        [DateFormat.FULL]: "dddd D MMMM YYYY",
+        [DateFormat.LONG]: "D MMMM YYYY",
+        [DateFormat.ISO8601]: ISO8601_YYYY_MM_DD,
+        [DateFormat.YYYYMMDD]: "YYYYMMDD",
+    },
+    [Locale.ENGLISH]: {
+        [DateFormat.FULL]: "dddd, D MMMM YYYY",
+        [DateFormat.LONG]: "D MMMM YYYY",
+        [DateFormat.ISO8601]: ISO8601_YYYY_MM_DD,
+        [DateFormat.YYYYMMDD]: "YYYYMMDD",
+    },
+};
+/**
+ * Represents a date (with year, month and day).
+ *
+ * @public
+ */
+class FDate {
+    value;
+    constructor(value) {
+        this.value = dayjs(value, ISO8601_YYYY_MM_DD, true);
+    }
+    /**
+     * Create {@link FDate} with an invalid state.
+     *
+     * @internal
+     */
+    static invalid() {
+        return new FDate("<invalid>");
+    }
+    /**
+     * Create {@link FDate} from current date.
+     *
+     * ```
+     * FDate.now()
+     * ```
+     *
+     * @public
+     */
+    static now() {
+        return new FDate();
+    }
+    /**
+     * Create {@link FDate} from ISO8601 string.
+     *
+     * ```
+     * FDate.fromIso("2022-04-20")
+     * ```
+     *
+     * @public
+     */
+    static fromIso(value) {
+        const match = value.match(/^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/);
+        if (match && match.groups) {
+            const date = new FDate(value);
+            const { month } = match.groups;
+            /* in dayjs (and native Date) when the day overflows (e.g. 31 feb)
+             * it increases the month, this is not the desired behaviour so we
+             * compare the parsed month with the original month, if they differ
+             * an invalid FDate is returned instead.*/
+            if (date.isValid() && date.month === parseInt(month, 10)) {
+                return date;
+            }
+        }
+        return FDate.invalid();
+    }
+    /**
+     * Create {@link FDate} from `Date`.
+     *
+     * ```
+     * FDate.fromDate(new Date())
+     * ```
+     *
+     * @public
+     */
+    static fromDate(value) {
+        return new FDate(value);
+    }
+    /**
+     * Create {@link FDate} from year, month, day.
+     *
+     * ```
+     * FDate.fromYearMonthDay(2023, 1, 1) // => 2023-01-01
+     * FDate.fromYearMonthDay("2023", "01", "01") // => 2023-01-01
+     * ```
+     *
+     * @public
+     */
+    static fromYearMonthDay(year, month, day) {
+        const paddedMonth = month.toString().padStart(2, "0");
+        const paddedDay = day.toString().padStart(2, "0");
+        const iso = `${year}-${paddedMonth}-${paddedDay}`;
+        return FDate.fromIso(iso);
+    }
+    /**
+     * Get the year.
+     *
+     * ```
+     * FDate.now().year()// => 2022
+     * ```
+     *
+     * @public
+     */
+    get year() {
+        return this.value.year();
+    }
+    /**
+     * Get the month.
+     *
+     * Months are one-indexed, so January is month 1.
+     *
+     * ```
+     * FDate.now().month()// => 1-12
+     * ```
+     *
+     * @public
+     */
+    get month() {
+        return this.value.month() + 1;
+    }
+    /**
+     * Get the week according to the Swedish locale.
+     *
+     * @public
+     */
+    get week() {
+        return this.value.locale(Locale.SWEDISH).week();
+    }
+    /**
+     * Get the day of the month.
+     *
+     * ```
+     * FDate.now().day// => 1-31
+     * ```
+     *
+     * @public
+     */
+    get day() {
+        return this.value.date();
+    }
+    /**
+     * Get the name of the month.
+     *
+     * ```
+     * FDate.now().monthName// => January
+     * ```
+     *
+     * @public
+     */
+    get monthName() {
+        if (this.isValid()) {
+            return this.value.locale(getLocale()).format("MMMM");
+        }
+        else {
+            return "";
+        }
+    }
+    /**
+     * Get the short name of the month.
+     *
+     * ```
+     * FDate.now().monthNameShort// => Jan
+     * ```
+     *
+     * @public
+     */
+    get monthNameShort() {
+        if (this.isValid()) {
+            return this.value.locale(getLocale()).format("MMM");
+        }
+        else {
+            return "";
+        }
+    }
+    /**
+     * Get the name of the day.
+     *
+     * ```
+     * FDate.now().dayName// => Monday
+     * ```
+     *
+     * @public
+     */
+    get dayName() {
+        if (this.isValid()) {
+            return this.value.locale(getLocale()).format("dddd");
+        }
+        else {
+            return "";
+        }
+    }
+    /**
+     * Get the short name of the day.
+     *
+     * ```
+     * FDate.now().dayNameShort// => Mon
+     * ```
+     *
+     * @public
+     */
+    get dayNameShort() {
+        if (this.isValid()) {
+            return this.value.locale(getLocale()).format("ddd");
+        }
+        else {
+            return "";
+        }
+    }
+    /**
+     * Get number of the day in a week.
+     * Returns `Weekday` enum.
+     * If date is invalid, `0` is returned.
+     *
+     * ```
+     * FDate.now().weekDay// => Weekday.MONDAY / 1
+     * ```
+     *
+     * @public
+     */
+    get weekDay() {
+        if (!this.isValid()) {
+            return 0;
+        }
+        const result = parseInt(this.value.format("d"), 10);
+        if (!result) {
+            return Weekday.SUNDAY;
+        }
+        return result;
+    }
+    /**
+     * This returns a `boolean` indicating whether the FDate object contains a valid date or not.
+     *
+     * ```
+     * FDate().isValid()// => boolean
+     * ```
+     *
+     * @public
+     */
+    isValid() {
+        return this.value.isValid();
+    }
+    /**
+     * Returns a cloned {@link FDate} object and set it to the start of month.
+     *
+     * @public
+     */
+    startOfMonth() {
+        return new FDate(this.value.startOf("month"));
+    }
+    /**
+     * Returns a cloned {@link FDate} object and set it to the end of month.
+     *
+     * @public
+     */
+    endOfMonth() {
+        return new FDate(this.value.endOf("month"));
+    }
+    /**
+     * Returns a new {@link FDate} object with a specified amount of days added.
+     * Specify a negative amount in order to subtract days.
+     *
+     * ```
+     * FDate().addDays(7)// => FDate
+     * ```
+     *
+     * @public
+     */
+    addDays(value) {
+        return new FDate(this.value.add(value, "day"));
+    }
+    /**
+     * Returns a cloned {@link FDate} object with a specified amount of months added.
+     * Specify a negative amount in order to subtract months.
+     *
+     * ```
+     * FDate().addMonths(7)// => FDate
+     * ```
+     *
+     * @public
+     */
+    addMonths(value) {
+        return new FDate(this.value.add(value, "month"));
+    }
+    /**
+     * Returns a new {@link FDate} object with a specified amount of years added.
+     * Specify a negative amount in order to subtract years.
+     *
+     * ```
+     * FDate().addYears(7)// => FDate
+     * ```
+     *
+     * @public
+     */
+    addYears(value) {
+        return new FDate(this.value.add(value, "year"));
+    }
+    next() {
+        return this.addDays(1);
+    }
+    /**
+     * Compares two {@link FDate} objects and returns `true` if they represent the
+     * same date.
+     *
+     * Invalid dates always returns `false`.
+     *
+     * @public
+     * @param rhs - The date to compare with.
+     * @returns `true` if the dates represent the same date.
+     */
+    equals(rhs) {
+        if (typeof rhs === "string") {
+            rhs = FDate.fromIso(rhs);
+        }
+        return this.value.isSame(rhs.value, "day");
+    }
+    /**
+     * Returns true if this date is before given date.
+     *
+     * If the dates are the same this function returns false.
+     */
+    isBefore(rhs) {
+        if (typeof rhs === "string") {
+            rhs = FDate.fromIso(rhs);
+        }
+        return this.value.isBefore(rhs.value);
+    }
+    /**
+     * Returns true if this date is after given date.
+     *
+     * If the dates are the same this function returns false.
+     */
+    isAfter(rhs) {
+        if (typeof rhs === "string") {
+            rhs = FDate.fromIso(rhs);
+        }
+        return this.value.isAfter(rhs.value);
+    }
+    /**
+     * Compares two {@link FDate} objects. Returns and integer indicating whenever
+     * `a` comes before or after or is equal to `b`.
+     *
+     * - `-1` if `a` beomes before `b`.
+     * - `0` if `a` and `b` are the same date.
+     * - `1` if `a` beomes after `b`.
+     *
+     * If either or both date is invalid the result is undefined behaviour and
+     * should not be relied on. Use {@link FDate.isValid} to ensure validity
+     * first, e.g. `myArray.filter(it => it.isValid())` before sorting.
+     *
+     * @public
+     * @param a - First date object to compare.
+     * @param b - Second date object to compare.
+     * @returns `-1`, `0` or `1`
+     */
+    static compare(a, b) {
+        if (typeof a === "string") {
+            a = FDate.fromIso(a);
+        }
+        if (typeof b === "string") {
+            b = FDate.fromIso(b);
+        }
+        const aInvalid = !a.isValid();
+        const bInvalid = !b.isValid();
+        if (aInvalid || bInvalid) {
+            if (aInvalid && bInvalid) {
+                return 0;
+            }
+            else if (aInvalid) {
+                return 1;
+            }
+            else {
+                return -1;
+            }
+        }
+        if (a.value.isSame(b.value)) {
+            return 0;
+        }
+        else if (a.value.isBefore(b.value)) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    }
+    /**
+     * Returns a string representation of the date.
+     *
+     * ```
+     * FDate().toString() // "2022-05-04"
+     * FDate().toString(DateFormat.FULL) // "onsdag 4 maj 2022"
+     * FDate().toString(DateFormat.LONG) // "4 maj 2022"
+     * FDate().toString(DateFormat.ISO8601) // "2022-04-20"
+     * ```
+     *
+     * @public
+     * @param format - Format to use.
+     */
+    toString(format = DateFormat.ISO8601) {
+        if (this.isValid()) {
+            const template = formatter[getLocale()][format];
+            return this.value.locale(getLocale()).format(template);
+        }
+        else {
+            return "";
+        }
+    }
+    /**
+     * To serialize as an ISO8601 string.
+     *
+     * ```
+     * FDate().toJSON() // "2019-01-25"
+     * ```
+     *
+     * @public
+     */
+    toJSON() {
+        return this.toString(DateFormat.ISO8601);
+    }
+}
+
+/**
+ * @public
+ */
+function parseDate(value) {
+    if (isEmpty(value)) {
+        return undefined;
+    }
+    const normalized = normalizeDateFormat(value);
+    if (!normalized) {
+        return undefined;
+    }
+    const date = FDate.fromIso(normalized);
+    if (date.isValid()) {
+        return date.toString();
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Strips all whitespace from the text (not only leading and trailing)
+ *
+ * @public
+ * @param text - Text to strip whitespace from.
+ * @returns Text with whitespace stripped.
+ */
+function stripWhitespace(text) {
+    return text.replace(/\s+/g, "");
+}
+
+const NUMBER_REGEXP$1 = /^([-]?[0-9]+)([,.][0-9]+)?$/;
+function replaceCommaWithDot(str) {
+    return str.replace(",", ".");
+}
+function replaceMinusSignWithDash(str) {
+    return str.replace("−", "-");
+}
+function replaceDotWithComma(str) {
+    return str.replace(".", ",");
+}
+function formatSwedishNotation(value, decimals) {
+    if (decimals !== undefined) {
+        // round
+        value = Number(value.toFixed(decimals));
+    }
+    // Workaround, replace dot with comma. Node doesn't have swedish locale
+    // installed as default. By having this workaround the applications
+    // doesn't need to install full-icu & cross-env to get correct
+    // formatting in jest tests.
+    return replaceDotWithComma(value.toLocaleString("sv-SE", {
+        minimumFractionDigits: decimals,
+    }));
+}
+/**
+ * Format number with thousand separator and use comma as decimal separator.
+ *
+ * @public
+ */
+function formatNumber(value, decimals) {
+    if (typeof value === "string") {
+        value = parseNumber(value) ?? "";
+    }
+    if (typeof value !== "number" || isNaN(value)) {
+        return undefined;
+    }
+    return formatSwedishNotation(value, decimals);
+}
+/**
+ * @public
+ */
+function parseNumber(value) {
+    if (isEmpty(value)) {
+        return undefined;
+    }
+    const stripped = stripWhitespace(value);
+    const numberString = replaceCommaWithDot(replaceMinusSignWithDash(stripped));
+    if (!NUMBER_REGEXP$1.test(numberString)) {
+        return undefined;
+    }
+    const number = Number(numberString);
+    return isNaN(number) ? undefined : number;
+}
+
+function getNowDetails(now) {
+    const nowIso = now.toString();
+    return {
+        nowCentury: nowIso.substring(0, 2),
+        nowYear: nowIso.substring(2, 4),
+        nowMonthDay: nowIso.substring(5, 7) + nowIso.substring(8, 10),
+    };
+}
+/**
+ * Resolves missing century.
+ *
+ * ```
+ * getCentury("22", "01", "01", true, FDate.now()) // => "19"
+ * ```
+ *
+ * @internal
+ */
+function resolveCentury(year, month, day, hasPlus, now) {
+    const { nowCentury, nowYear, nowMonthDay } = getNowDetails(now);
+    let subtractCenturies = 0;
+    if (hasPlus) {
+        subtractCenturies += 1;
+    }
+    if (year > nowYear ||
+        (year === nowYear && !hasPlus && `${month}${day}` > nowMonthDay)) {
+        subtractCenturies += 1;
+    }
+    return (Number(nowCentury) - subtractCenturies).toString();
+}
+
+const PERSONNUMMER_REGEXP = /^(?<century>\d{2})?(?<year>\d{2})(?<month>\d{2})(?<day>\d{2})(?<sign>-|\+)?(?<check>\d{4})$/;
+function getDayWithoutSamordning(day) {
+    return (Number(day) % 60).toString().padStart(2, "0");
+}
+function getPersonnummerString(century, year, month, day, check) {
+    return `${century}${year}${month}${day}-${check}`;
+}
+/**
+ * Checks if date is valid and within valid period.
+ * The valid period is between 1840-05-06 (first registered personnummer) and today's date.
+ *
+ * @internal
+ */
+function isValidDate(date, now) {
+    if (!date.isValid() || date.isBefore("1840-05-06") || date.isAfter(now)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Parses 10- and 12-digit personnummers.
+ *
+ * @public
+ */
+function parsePersonnummer(value, now = FDate.now()) {
+    if (!isSet(value)) {
+        return undefined;
+    }
+    const match = stripWhitespace(value).match(PERSONNUMMER_REGEXP);
+    if (!match) {
+        return undefined;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- expected
+    const { year, month, day, sign, check } = match.groups;
+    const dayWithoutSamordning = getDayWithoutSamordning(day);
+    const century = match.groups?.century ??
+        resolveCentury(year, month, dayWithoutSamordning, sign === "+", now);
+    // consider date as valid when samordningsnummer equals "60" (it means birthday is unknown)
+    if (day === "60") {
+        return getPersonnummerString(century, year, month, day, check);
+    }
+    const date = FDate.fromYearMonthDay(century + year, month, dayWithoutSamordning);
+    if (!isValidDate(date, now)) {
+        return undefined;
+    }
+    return getPersonnummerString(century, year, month, day, check);
+}
+/**
+ * Parses 10- and 12-digit personnummers with Luhn validation.
+ *
+ * @public
+ */
+function parsePersonnummerLuhn(value) {
+    const parsed = parsePersonnummer(value);
+    if (!parsed) {
+        return undefined;
+    }
+    if (!validChecksum(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+/**
+ * Formats personnummer to a 10-digit string.
+ *
+ * @public
+ */
+function formatPersonnummer(value) {
+    if (!isSet(value)) {
+        return undefined;
+    }
+    const currentYear = FDate.now().year;
+    const year = Number(value.substring(0, 4));
+    if (currentYear - year >= 100) {
+        return value.substring(2).replace("-", "+");
+    }
+    return value.substring(2);
+}
+
+const PLUSGIRO_REGEXP = /^\d{1,7}[-]?\d{1}$/;
+function hyphenShouldBeAdded(value) {
+    return value.length >= 2 && value.length <= 8;
+}
+/**
+ * @public
+ */
+function parsePlusgiro(value) {
+    if (isEmpty(value)) {
+        return undefined;
+    }
+    /**
+     * Add spaces between each pair of digits before the hyphen back-to-front.
+     * If the number of digits is odd then the first pair in the string can be a single digit.
+     * If the number of characters is 9, there will be a space after the first 3 characters.
+     */
+    value = value.replace(/ /g, "");
+    value = value.replace(/\D/g, "");
+    if (!PLUSGIRO_REGEXP.test(value) ||
+        !testLuhnChecksum(value.replace(/\D/g, ""))) {
+        return undefined;
+    }
+    if (hyphenShouldBeAdded(value)) {
+        value = `${value.substring(0, value.length - 1)}-${value[value.length - 1]}`;
+    }
+    const startOffset = 4;
+    let formattedString = value.substring(value.length - startOffset, value.length);
+    const step = 2;
+    for (let i = value.length - startOffset; i >= (value.length === 9 ? 3 : 1); i -= step) {
+        formattedString = `${value.substring(Math.max(i - step, 0), i)} ${formattedString}`;
+    }
+    if (value.length === 9) {
+        formattedString = value.substring(0, 1) + formattedString;
+    }
+    return formattedString;
+}
+
+/**
+ * @internal
+ */
+const POSTAL_CODE_REGEXP = /^([1-9]{1}\d{2}) ?(\d{2})$/;
+/**
+ * @public
+ */
+function formatPostalCode(value) {
+    if (isEmpty(value)) {
+        return undefined;
+    }
+    const match = value.match(POSTAL_CODE_REGEXP);
+    if (match === null) {
+        return undefined;
+    }
+    return `${match[1]} ${match[2]}`;
+}
+/**
+ * @public
+ */
+function parsePostalCode(value) {
+    return formatPostalCode(value);
+}
+
+const ORGANISATIONSNUMMER_REGEXP = /^([0-9]{6})-?([0-9]{4})$/;
+/**
+ * @public
+ */
+function parseOrganisationsnummer(value) {
+    if (isEmpty(value)) {
+        return undefined;
+    }
+    const match = value.match(ORGANISATIONSNUMMER_REGEXP);
+    if (!match) {
+        return undefined;
+    }
+    if (!testLuhnChecksum(`${match[1]}${match[2]}`)) {
+        return undefined;
+    }
+    return `${match[1]}-${match[2]}`;
+}
+
+/**
+ * @public
+ */
+function formatPercent(modelValue, decimals) {
+    return formatNumber(modelValue, decimals);
+}
+/**
+ * @public
+ */
+function parsePercent(viewValue) {
+    return parseNumber(viewValue);
+}
+
+/**
+ * Add a listener to each item in the list of elements
+ *
+ * @public
+ */
+function addFocusListener(elements, listener) {
+    for (const element of elements) {
+        element.addEventListener("focus", listener);
+    }
+}
+
+/**
+ * Compares the position of the given node against another node in any document.
+ *
+ * Unset elements (e.g. `null`) are undefined behaviour but the current
+ * non-contractural behaviour is to put them at the end of the sorted
+ * array. The caller should ensure those elements are removed before sorting.
+ *
+ * @example
+ * ```ts
+ * const sorted = listOfElements.sort(documentOrderComparator);
+ * ```
+ *
+ * @public
+ */
+function documentOrderComparator(a, b) {
+    if (!a) {
+        return 1;
+    }
+    if (!b) {
+        return -1;
+    }
+    const BITMASK = Node.DOCUMENT_POSITION_DISCONNECTED | Node.DOCUMENT_POSITION_PRECEDING;
+    const result = a.compareDocumentPosition(b) & BITMASK;
+    /* After the bitmask result can only have three distinct values:
+     *
+     * Result   Comparator   Description
+     * ------   ----------   -----------
+     *      0           -1   A follow B
+     *      1            0   Disconnected
+     *      2            1   A preceed B
+     *
+     * Given above table we can compute final comparator value by subtracting 1.
+     */
+    return result - 1;
+}
+
+/**
+ * Check if an element is visible in the dom
+ *
+ * @public
+ */
+function isVisible(element) {
+    return Boolean(element.offsetWidth ||
+        element.offsetHeight ||
+        element.getClientRects().length);
+}
+
+const FRAMERATE = 60;
+function easeInEaseOut(a, b, s) {
+    return a + ((b - a) * (1 + Math.cos(Math.PI + s * Math.PI))) / 2;
+}
+function elementTop(element) {
+    const rect = element.getBoundingClientRect();
+    const scrollTop = window.pageYOffset;
+    const clientTop = document.documentElement.clientTop;
+    return rect.top + scrollTop - clientTop;
+}
+function scrollTo(element, arg = 0) {
+    if (typeof arg === "number") {
+        const offset = arg;
+        const bodyRect = document.body.getBoundingClientRect();
+        const elemRect = element.getBoundingClientRect();
+        const scroll = elemRect.top - bodyRect.top - offset;
+        window.scrollTo({ top: scroll, behavior: "smooth" });
+        return Promise.resolve();
+    }
+    else {
+        return scrollToSlow(element, arg.duration || 500, arg.offset || 0);
+    }
+}
+/**
+ * Scroll to element with given duration
+ *
+ * @param element - Element to scroll into view
+ * @param duration - Duration in milliseconds
+ * @param offset - Set vertical offset, default 0px
+ */
+function scrollToSlow(element, duration, offset = 0) {
+    const steps = (duration / 1000) * FRAMERATE;
+    const interval = duration / steps;
+    const target = elementTop(element) - offset;
+    const scrollRange = target - window.pageYOffset;
+    function tween(s) {
+        return target - easeInEaseOut(scrollRange, 0, s);
+    }
+    return new Promise((resolve) => {
+        let stepsLeft = steps;
+        const requestAnimationFrame = setInterval(() => {
+            if (stepsLeft-- > 0) {
+                const s = 1 - stepsLeft / steps;
+                const top = tween(s);
+                window.scrollTo({ top, left: 0 });
+            }
+            else {
+                clearInterval(requestAnimationFrame);
+                resolve();
+            }
+        }, interval);
+    });
+}
+
+const sym = Symbol("focus-stack");
+let _stackHandleCounter = 0;
+const _focusElementStack = [];
+const TABBABLE_ELEMENT_SELECTOR = [
+    "a[href]",
+    "area[href]",
+    "input",
+    "select",
+    "textarea",
+    "button",
+    "iframe",
+    "object",
+    "embed",
+    "*[contenteditable]",
+    '*[tabindex]:not([tabindex="-1"])',
+].join(", ");
+function isHTMLElement(element) {
+    return Boolean(element && element instanceof HTMLElement);
+}
+/**
+ * Give focus to a given element.
+ *
+ * For convenience it will ignore `null` and `undefined` as element parameter.
+ *
+ * If in a Vue context, please refer to the `focus` method included in `@fkui/vue`.
+ *
+ * @public
+ * @param element - Element to focus.
+ * @param options - Focus options. If you pass boolean `true` or `false` it sets the `force` option.
+ */
+function focus(element, options = {}) {
+    if (typeof options === "boolean") {
+        options = { force: options };
+    }
+    if (isHTMLElement(element)) {
+        if (options.force && !isFocusable(element)) {
+            element.setAttribute("tabindex", "-1");
+        }
+        const { force, scrollToTop, ...params } = options;
+        element.focus(params);
+        if (scrollToTop) {
+            element.focus({ ...params, preventScroll: true });
+            scrollTo(element);
+        }
+        else {
+            element.focus(params);
+        }
+    }
+}
+/**
+ * Check if an element is focusable (visible and either interactive or with
+ * tabindex). This includes programatically focusable elements.
+ *
+ * @public
+ * @param element - An `Element` for which to test focusability.
+ * @returns `true` if the element is focusable, otherwise `false`.
+ */
+function isFocusable(element) {
+    const visible = element instanceof HTMLElement ? isVisible(element) : false;
+    return (isTabbable(element) || (visible && element.matches('*[tabindex="-1"]')));
+}
+/**
+ * Check if an element is disabled.
+ *
+ * @public
+ * @param element - An `Element`to test disabled.
+ * @returns `true`if the element is disabled.
+ *
+ */
+function isDisabled(element) {
+    return Boolean(element.disabled);
+}
+/**
+ * Check if an element is tabbable (visible and either interactive or
+ * non-negative tabindex). This does not include programatically focusable
+ * elements.
+ *
+ * @public
+ * @param element - An `Element` for which to test focusability.
+ * @returns `true` if the element is focusable, otherwise `false`.
+ */
+function isTabbable(element) {
+    const tabindexAttr = element instanceof HTMLElement ? element.tabIndex : 0;
+    const visible = element instanceof HTMLElement ? isVisible(element) : false;
+    return (!isDisabled(element) &&
+        tabindexAttr !== -1 &&
+        visible &&
+        element.matches(TABBABLE_ELEMENT_SELECTOR));
+}
+/**
+ * Find all visible and tabbable elements.
+ *
+ * @public
+ * @param root - Element or document to find tabbable elements in.
+ * @returns List of matching elements
+ */
+function findTabbableElements(root) {
+    const selector = TABBABLE_ELEMENT_SELECTOR;
+    const nodes = root.querySelectorAll(selector);
+    return Array.from(nodes).filter(isTabbable);
+}
+/**
+ * Focus first focusable element among given root element's hierarchy.
+ *
+ * @public
+ * @param rootElement - Root element.
+ */
+function focusFirst(rootElement) {
+    const element = findTabbableElements(rootElement).shift();
+    if (element) {
+        focus(element);
+    }
+}
+/**
+ * Focus last focusable element among given root element's hierarchy.
+ *
+ * @public
+ * @param rootElement - Root element.
+ */
+function focusLast(rootElement) {
+    const element = findTabbableElements(rootElement).pop();
+    if (element) {
+        focus(element);
+    }
+}
+/**
+ * Restore focus to a previous element. Use this in combination with {@link saveFocus}
+ *
+ * @public
+ */
+function restoreFocus() {
+    try {
+        forcePopFocus();
+    }
+    catch {
+        /* do nothing */
+    }
+}
+/**
+ * Save a DOM reference to the active element for later use.
+ *
+ * @public
+ * @param document - Document element
+ */
+function saveFocus(document) {
+    if (document.activeElement instanceof HTMLElement) {
+        pushFocus();
+    }
+}
+/**
+ * Save current active element focus on the stack and set focus on element
+ *
+ * @public
+ * @param element - The element to set focus on
+ */
+function pushFocus(element) {
+    const stackFrame = {
+        id: _stackHandleCounter++,
+        element: document.activeElement,
+    };
+    _focusElementStack.push(stackFrame);
+    focus(element);
+    return { [sym]: stackFrame.id };
+}
+/**
+ * Restore the focus on the last element from the stack
+ *
+ * @public
+ * @throws Error when pop is called on an empty focus stack
+ * @throws Error when pop is called without a valid StackHandle
+ */
+function popFocus(handle) {
+    if (_focusElementStack.length === 0) {
+        const emptyStackErrorMsg = "Can not call pop on an empty focus stack";
+        if (configLogic.production) {
+            // eslint-disable-next-line no-console -- expected to log
+            console.error(emptyStackErrorMsg);
+            return;
+        }
+        else {
+            throw new Error(emptyStackErrorMsg);
+        }
+    }
+    const top = _focusElementStack.pop();
+    if (top?.id !== handle[sym]) {
+        const outOfOrderErrorMsg = `push/pop called out-of-order. Expected stack handle id: ${top?.id} but got ${handle[sym]}`;
+        if (configLogic.production) {
+            // eslint-disable-next-line no-console -- expected to log
+            console.error(outOfOrderErrorMsg);
+            return;
+        }
+        else {
+            throw new Error(outOfOrderErrorMsg);
+        }
+    }
+    focus(top?.element);
+}
+/**
+ * Restore the focus on the last element from the stack
+ * Prefer `popFocus(handle: StackHandle)`
+ *
+ * @internal
+ */
+function forcePopFocus() {
+    if (_focusElementStack.length === 0) {
+        throw new Error("Can not call pop on an empty focus stack");
+    }
+    const top = _focusElementStack.pop();
+    focus(top?.element);
+}
+
+/**
+ * Handle tab focus between given containers focusable elements
+ *
+ * @public
+ * @param event - tab KeyboardEvent
+ * @param container - containing focusable elements
+ */
+function handleTab(event, container) {
+    const elements = findTabbableElements(container);
+    let targetIndex = elements.indexOf(event.target);
+    if (event.shiftKey) {
+        targetIndex--;
+    }
+    else {
+        targetIndex++;
+    }
+    if (targetIndex < 0) {
+        targetIndex = elements.length - 1;
+    }
+    else if (targetIndex >= elements.length) {
+        targetIndex = 0;
+    }
+    focus(elements[targetIndex]);
+    event.preventDefault();
+}
+
+/**
+ * Check if element is of type radiobutton or checkbox
+ *
+ * @public
+ */
+function isRadiobuttonOrCheckbox(element) {
+    return (element instanceof HTMLInputElement &&
+        (element.type === "radio" || element.type === "checkbox"));
+}
+
+/**
+ * Check if element is a form element
+ *
+ * Also see {@link isValidatableHTMLElement} for a similar function but
+ * including HTMLFieldSetElement.
+ *
+ * @public
+ * @param element - Element to test
+ */
+function isValidatableFormElement(element) {
+    return (element instanceof HTMLInputElement ||
+        element instanceof HTMLSelectElement ||
+        element instanceof HTMLTextAreaElement);
+}
+
+/**
+ * Check if an element is fully visible in the viewport
+ *
+ * @public
+ */
+function isVisibleInViewport(element) {
+    const rect = element.getBoundingClientRect();
+    return Boolean(rect.top >= 0 &&
+        rect.left >= 0 &&
+        rect.bottom <=
+            (window.innerHeight || document.documentElement.clientHeight) &&
+        rect.right <=
+            (window.innerWidth || document.documentElement.clientWidth));
+}
+
+/**
+ * Remove listener for each item in the list of elements
+ *
+ * @public
+ */
+function removeFocusListener(elements, listener) {
+    for (const element of elements) {
+        element.removeEventListener("focus", listener);
+    }
+}
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    addFocusListener: addFocusListener,
+    documentOrderComparator: documentOrderComparator,
+    findTabbableElements: findTabbableElements,
+    focus: focus,
+    focusFirst: focusFirst,
+    focusLast: focusLast,
+    handleTab: handleTab,
+    isFocusable: isFocusable,
+    isRadiobuttonOrCheckbox: isRadiobuttonOrCheckbox,
+    isTabbable: isTabbable,
+    isValidatableFormElement: isValidatableFormElement,
+    isVisible: isVisible,
+    isVisibleInViewport: isVisibleInViewport,
+    popFocus: popFocus,
+    pushFocus: pushFocus,
+    removeFocusListener: removeFocusListener,
+    restoreFocus: restoreFocus,
+    saveFocus: saveFocus,
+    scrollTo: scrollTo
+});
+
+class DefaultTranslationProvider {
+    language = "sv";
+    get currentLanguage() {
+        return this.language;
+    }
+    async changeLanguage(language) {
+        this.language = language;
+    }
+    translate(key, defaultValueOrArgs, args) {
+        if (this.language === "cimode") {
+            return key;
+        }
+        if (!isSet(defaultValueOrArgs) ||
+            typeof defaultValueOrArgs !== "string") {
+            throw new Error("Translation failed: No default value specified (key translation is not supported by the default provider)");
+        }
+        return isSet(args)
+            ? this.interpolate(defaultValueOrArgs, args)
+            : defaultValueOrArgs;
+    }
+    interpolate(defaultValue, args) {
+        return defaultValue.replace(/{{\s*([^\s]+)\s*}}/g, (match, key) => {
+            return String(args[key]) || match;
+        });
+    }
+}
+
+class TranslationServiceImpl {
+    provider = new DefaultTranslationProvider();
+    changeProvider(newProvider) {
+        this.provider = newProvider;
+    }
+}
+/**
+ * @public
+ */
+const TranslationService = new TranslationServiceImpl();
+
+/**
+ * Builder to create validation error message map.
+ *
+ * @public
+ */
+class ValidationErrorMessageBuilder {
+    /**
+     * Create a new builder.
+     */
+    static create() {
+        return new ValidationErrorMessageBuilder();
+    }
+    validatorMessageMap;
+    constructor() {
+        this.validatorMessageMap = {};
+    }
+    /**
+     * Map the validator name message towards an error message.
+     *
+     * @param validatorName - the name of the validator
+     * @param message - the error message
+     * @param elementType - limit to a specific element type
+     */
+    map(validatorName, message, elementType) {
+        let key = validatorName;
+        if (elementType) {
+            key += `.${elementType}`;
+        }
+        this.validatorMessageMap[key] = message;
+        return this;
+    }
+    /**
+     * Validators that coexists on same element can have a combined message,
+     * i.e. if a element have the `required` and the `personnummer` validator
+     * the required error message could be combined with
+     * `mapCombined('required','personnummer', 'You must enter a social security number!');`.
+     *
+     * @param validatorName - the name of the validator
+     * @param dependentValidatorName - the name of the combined validator
+     * @param message - the error message
+     * @param elementType - limit to a specific element type
+     */
+    mapCombined(validatorName, dependentValidatorName, message, elementType) {
+        return this.map(`${validatorName}.${dependentValidatorName}`, message, elementType);
+    }
+    /**
+     * Build the translation map.
+     *
+     * @returns the created map.
+     */
+    build() {
+        return this.validatorMessageMap;
+    }
+}
+
+/**
+ * @public
+ */
+function getErrorMessages() {
+    return ValidationErrorMessageBuilder.create()
+        .map("bankAccountNumber", "Kontonumret är inte rätt ifyllt. Kolla att det stämmer.")
+        .mapCombined("required", "bankAccountNumber", "Fyll i ett kontonummer.")
+        .map("bankgiro", "Skriv bankgironumret med sju eller åtta siffror och bindestreck.")
+        .mapCombined("required", "bankgiro", "Fyll i bankgironumret.")
+        .mapCombined("maxLength", "bankgiro", "Bankgironumret kan inte ha mer än 9 tecken.")
+        .map("clearingNumber", "Clearingnumret är inte rätt ifyllt. Kolla att det stämmer.")
+        .mapCombined("required", "clearingNumber", "Fyll i ett clearingnummer.")
+        .map("currency", "Fyll i ett belopp.")
+        .mapCombined("required", "currency", "Fyll i ett belopp.")
+        .map("date", "Du har skrivit ett felaktigt datum.")
+        .mapCombined("required", "date", "Välj ett datum.")
+        .map("dateFormat", "Skriv datumet med åtta siffror.")
+        .map("decimal", "Fyll i ett värde med rätt antal decimaler.")
+        .map("email", "Mejladressen är inte korrekt ifylld.")
+        .mapCombined("required", "email", "Fyll i en mejladress.")
+        .mapCombined("matches", "email", "Kolla att mejladressen stämmer.")
+        .map("greaterThan", "Fyll i en högre siffra.")
+        .map("integer", "Fyll i siffror utan decimal.")
+        .mapCombined("required", "integer", "Fyll i en siffra.")
+        .map("lessThan", "Du har fyllt i en för hög siffra.")
+        .map("minDate", "Datumet ligger för långt bak i tiden.")
+        .mapCombined("minDate", "date", "Datumet ligger för långt bak i tiden.")
+        .map("maxDate", "Datumet ligger för långt fram i tiden.")
+        .mapCombined("maxDate", "date", "Datumet ligger för långt fram i tiden.")
+        .map("maxValue", "Du har fyllt i en för hög siffra.")
+        .map("minValue", "Fyll i en högre siffra.")
+        .map("number", "Du har fyllt i ett ogiltigt tecken. Fyll i siffror.")
+        .mapCombined("required", "number", "Fyll i en siffra.")
+        .mapCombined("minValue", "number", "Fyll i en högre siffra.")
+        .mapCombined("maxValue", "number", "Du har fyllt i en för hög siffra.")
+        .map("organisationsnummer", "Fyll i organisationsnumret med 10 siffror, till exempel 999999-9999.")
+        .mapCombined("required", "organisationsnummer", "Fyll i organisationsnumret med 10 siffror, till exempel 999999-9999.")
+        .mapCombined("maxLength", "organisationsnummer", "Organisationsnumret kan inte ha mer än 11 tecken.")
+        .map("percent", "Fyll i procent med en siffra.")
+        .mapCombined("integer", "percent", "Fyll i procent utan decimal.")
+        .mapCombined("required", "percent", "Fyll i en siffra.")
+        .mapCombined("minValue", "percent", "Fyll i en högre siffra.")
+        .mapCombined("maxValue", "percent", "Fyll i en lägre siffra.")
+        .map("personnummerFormat", "Skriv personnumret med 10 siffror.")
+        .mapCombined("required", "personnummerFormat", "Skriv personnumret med 10 siffror.")
+        .mapCombined("maxLength", "personnummerFormat", "Skriv personnumret med 10 siffror.")
+        .map("personnummerLuhn", "Kolla att personnumret stämmer.")
+        .map("postalCode", "Fyll i postnumret med fem siffror.")
+        .mapCombined("required", "postalCode", "Fyll i ett postnummer.")
+        .mapCombined("maxLength", "postalCode", "Postnumret kan inte ha mer än 13 tecken.")
+        .map("phoneNumber", "Telefonnumret är inte rätt ifyllt.")
+        .mapCombined("required", "phoneNumber", "Fyll i ett telefonnummer.")
+        .mapCombined("matches", "phoneNumber", "Kolla att telefonnumret stämmer.")
+        .map("plusgiro", "Skriv plusgironumret med siffror och bindestreck.")
+        .mapCombined("required", "plusgiro", "Fyll i plusgironumret.")
+        .mapCombined("maxLength", "plusgiro", "Plusgironumret kan inte ha mer än 11 tecken.")
+        .map("matches", "Fälten stämmer inte överens.")
+        .map("required", "Fyll i text.")
+        .map("required", "Välj minst ett alternativ.", "checkbox")
+        .map("required", "Välj ett av alternativen.", "radio")
+        .map("required", "Välj ett av alternativen.", "select")
+        .map("invalidDates", "Du kan inte välja det här datumet.")
+        .map("invalidWeekdays", "Du kan inte välja det här datumet.")
+        .map("whitelist", 'Fältet innehåller otillåtna tecken. Exempel på ogiltiga tecken är /, % och ".')
+        .build();
+}
+
+/**
+ * @internal
+ */
+function createFieldsetValidator(element, validationService) {
+    /* eslint-disable-next-line no-new -- technical debt, this should be
+     * refactored as to not rely of side-effects of the constructor */
+    new FieldsetValidationHandler(element, validationService);
+}
+class FieldsetValidationHandler {
+    hasDocumentListener = false;
+    documentFocusInRef = undefined;
+    element;
+    validationService;
+    constructor(element, validationService) {
+        Object.assign(this);
+        this.element = element;
+        this.validationService = validationService;
+        element.addEventListener("focusin", (event) => this.onFocusIn(event));
+        // Handle checking of input by using keyboard (space)
+        element.addEventListener("change", this.documentFocusIn.bind(this));
+        Array.from(this.element.querySelectorAll("input[type='checkbox'], input[type='radio']"))
+            .filter((childElement) => childElement.closest("fieldset") === element)
+            .forEach((childElement) => {
+            childElement.setAttribute("required", "");
+        });
+    }
+    hasFocusableTarget(target) {
+        return target
+            ? Array.from(this.element.querySelectorAll("input, label")).some((element) => element === target)
+            : false;
+    }
+    onFocusIn(event) {
+        // IE11 (not Chrome / FF) trigger focusin-event on legends and other elements inside the fieldset
+        // So we need to check the event target, if it's focusable.
+        if (this.hasFocusableTarget(event.target) &&
+            !this.hasDocumentListener) {
+            this.documentFocusInRef = this.documentFocusIn.bind(this);
+            document.addEventListener("focusin", this.documentFocusInRef);
+            document.addEventListener("click", this.documentFocusInRef);
+            this.hasDocumentListener = true;
+        }
+    }
+    documentFocusIn(event) {
+        this.validationService.setTouched(this.element);
+        const children = Array.from(this.element.querySelectorAll("input"));
+        for (const childElement of children) {
+            this.validationService.setTouched(childElement);
+        }
+        if (!this.hasFocusableTarget(event.target)) {
+            this.removeEventListeners();
+        }
+        else if (event.target.checked) {
+            this.validateFieldsetAndChildren();
+        }
+    }
+    removeEventListeners() {
+        if (this.hasDocumentListener && this.documentFocusInRef) {
+            document.removeEventListener("focusin", this.documentFocusInRef);
+            document.removeEventListener("click", this.documentFocusInRef);
+            this.hasDocumentListener = false;
+            this.validateFieldsetAndChildren();
+        }
+    }
+    validateFieldsetAndChildren() {
+        const validatableElements = document.querySelectorAll(`fieldset#${this.element.id}, #${this.element.id} input[type='checkbox'], #${this.element.id} input[type='radio']`);
+        validatableElements.forEach((element) => {
+            if (element.id) {
+                this.validationService.validateElement(element.id);
+            }
+        });
+    }
+}
+
+/**
+ * Registered validators.
+ *
+ * @internal
+ */
+const registry = {};
+
+/**
+ * Returns validation error message candidates in prioritized order.
+ *
+ * @internal
+ */
+function getCandidates(validatorName, validators, elementType) {
+    const candidates = [];
+    const combinedNames = validators.map((it) => `${validatorName}.${it.name}`);
+    if (elementType) {
+        const combinedNamesWithType = combinedNames.map((it) => `${it}.${elementType}`);
+        candidates.push(...combinedNamesWithType);
+    }
+    candidates.push(...combinedNames);
+    if (elementType) {
+        candidates.push(`${validatorName}.${elementType}`);
+    }
+    candidates.push(validatorName);
+    return candidates;
+}
+
+/**
+ * Resolves element type for a `ValidatableHTMLElement`.
+ *
+ * Input types other than text, radio, checkbox returns \"text\".
+ * Fieldset returns \"radio\" or \"checkbox\" when it contains radio or checkbox elements.
+ *
+ * @internal
+ */
+function getElementType(element) {
+    if (element instanceof HTMLInputElement) {
+        return element.type === "checkbox"
+            ? "checkbox"
+            : element.type === "radio"
+                ? "radio"
+                : "text";
+    }
+    else if (element instanceof HTMLTextAreaElement) {
+        return "textarea";
+    }
+    else if (element instanceof HTMLSelectElement) {
+        return "select";
+    }
+    else if (element instanceof HTMLFieldSetElement) {
+        return getElementType(element.querySelector("input[type='checkbox'], input[type='radio']"));
+    }
+}
+
+/**
+ * Returns true if given element is a validatable element.
+ *
+ * Also see {@link isValidatableFormElement} for a similar function but
+ * excluding HTMLFieldSetElement.
+ *
+ * @public
+ * @param element - Element to test
+ */
+function isValidatableHTMLElement(element) {
+    return (element instanceof HTMLInputElement ||
+        element instanceof HTMLTextAreaElement ||
+        element instanceof HTMLSelectElement ||
+        element instanceof HTMLFieldSetElement);
+}
+/**
+ * @internal
+ */
+function isFieldset(element) {
+    return element instanceof HTMLFieldSetElement;
+}
+function hasValidators(element) {
+    return typeof element.dataset.validation === "string";
+}
+class ValidationServiceImpl {
+    validationStates = {};
+    elementValidatorsReferences = {};
+    validationErrorMessages = {};
+    constructor() {
+        this.addValidationErrorMessages(getErrorMessages());
+    }
+    getElementsAndValidators() {
+        return this.elementValidatorsReferences;
+    }
+    get isAnyTouched() {
+        return Object.values(this.validationStates).some((item) => item.touched === true);
+    }
+    addValidationErrorMessages(validationErrorMessages) {
+        this.validationErrorMessages = {
+            ...this.validationErrorMessages,
+            ...validationErrorMessages,
+        };
+    }
+    registerValidator(validator) {
+        const { name } = validator;
+        registry[name] = validator;
+    }
+    hasExistingReference(elementValidatorsReference, element) {
+        return (isSet(elementValidatorsReference) &&
+            elementValidatorsReference.element === element);
+    }
+    shouldApplyNewConfigOnBaseConfig(isBaseConfigs, elementValidatorsReference) {
+        return (!isBaseConfigs &&
+            isSet(elementValidatorsReference.baseValidatorConfigs));
+    }
+    decideEffectiveValidatorReference(element, newValidatorConfigs, isBaseConfigs) {
+        const elementValidatorsReference = this.elementValidatorsReferences[element.id];
+        const hasExistingReference = this.hasExistingReference(elementValidatorsReference, element);
+        let validatorConfigs;
+        if (!hasExistingReference) {
+            validatorConfigs = newValidatorConfigs;
+        }
+        else if (this.shouldApplyNewConfigOnBaseConfig(isBaseConfigs, elementValidatorsReference)) {
+            validatorConfigs = this.mergeValidatorConfigs(elementValidatorsReference.baseValidatorConfigs, newValidatorConfigs);
+        }
+        else if (isBaseConfigs) {
+            validatorConfigs = this.mergeValidatorConfigs(newValidatorConfigs, elementValidatorsReference.validatorConfigs);
+            elementValidatorsReference.baseValidatorConfigs =
+                newValidatorConfigs;
+        }
+        else {
+            validatorConfigs = newValidatorConfigs;
+        }
+        return validatorConfigs;
+    }
+    dispatchValidationConfig(validatorConfigs, element) {
+        const event = new CustomEvent("validation-config-update", {
+            bubbles: false,
+            detail: { config: validatorConfigs },
+        });
+        element.dispatchEvent(event);
+    }
+    removeValidatorsFromElement(element) {
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Technical debt, a map would have been better.
+        delete this.elementValidatorsReferences[element.id];
+    }
+    addValidatorsToElement(element, newValidatorConfigs, isBaseConfigs = false) {
+        if (!isValidatableHTMLElement(element)) {
+            return;
+        }
+        const validatorConfigs = this.decideEffectiveValidatorReference(element, newValidatorConfigs, isBaseConfigs);
+        this.dispatchValidationConfig(validatorConfigs, element);
+        if (element instanceof HTMLFieldSetElement) {
+            createFieldsetValidator(element, this);
+        }
+        this.setRequiredAttribute(element, validatorConfigs);
+        // Deprecated: SFKUI-4412 personnummerValidator is deprecated. Replace with personnummerFormat and personnummerLuhn
+        // Legacy compability tests cant be found here: @fkui/vue:src\components\FTextField\FTextField.cy.ts
+        if (validatorConfigs["personnummer"] !== undefined) {
+            const oldConfig = validatorConfigs["personnummer"];
+            validatorConfigs["personnummerFormat"] = oldConfig;
+            validatorConfigs["personnummerLuhn"] = oldConfig;
+            delete validatorConfigs.personnummer;
+        }
+        const foundValidators = this.getValidators(validatorConfigs);
+        // set data-validation attribute to indicate that validation is activated on the element
+        if (foundValidators.length > 0) {
+            element.dataset.validation = "";
+        }
+        const useInstantValidation = this.useInstantValidation(foundValidators, validatorConfigs);
+        let elementValidatorsReference = this.elementValidatorsReferences[element.id];
+        if (this.hasExistingReference(elementValidatorsReference, element)) {
+            elementValidatorsReference.validatorConfigs = validatorConfigs;
+            elementValidatorsReference.validators = foundValidators;
+            elementValidatorsReference.instant = useInstantValidation;
+        }
+        else {
+            elementValidatorsReference = {
+                validators: foundValidators,
+                validatorConfigs: validatorConfigs,
+                element,
+                instant: useInstantValidation,
+                baseValidatorConfigs: isBaseConfigs
+                    ? validatorConfigs
+                    : undefined,
+            };
+            this.elementValidatorsReferences[element.id] =
+                elementValidatorsReference;
+            this.createEventListeners(elementValidatorsReference);
+        }
+    }
+    mergeValidatorConfigs(baseConfig, newConfig) {
+        const required = isSet(newConfig.required)
+            ? { required: {} }
+            : undefined;
+        return {
+            ...required,
+            ...baseConfig,
+            ...newConfig,
+        };
+    }
+    createEventListeners(elementValidatorsReference) {
+        const element = elementValidatorsReference.element;
+        if (!(element instanceof HTMLFieldSetElement)) {
+            element.addEventListener("input", () => {
+                const validationState = this.getExistingStateOrSetDefault(element);
+                validationState.serverError = undefined;
+                if (elementValidatorsReference.instant) {
+                    validationState.touched = true;
+                    this.validateAndDispatchEvent("input", {
+                        validationState,
+                        elementValidatorsReference,
+                    });
+                }
+                else {
+                    element.dispatchEvent(new CustomEvent("pending-validity", {
+                        bubbles: false,
+                    }));
+                }
+            });
+            element.addEventListener("change", () => {
+                const validationState = this.getExistingStateOrSetDefault(element);
+                validationState.touched = true;
+                this.validateAndDispatchEvent("change", {
+                    validationState,
+                    elementValidatorsReference,
+                });
+            });
+            element.addEventListener("blur", () => {
+                const validationState = this.getExistingStateOrSetDefault(element);
+                validationState.touched = true;
+                this.validateAndDispatchEvent("blur", {
+                    validationState,
+                    elementValidatorsReference,
+                });
+            });
+        }
+        element.addEventListener("validate", () => {
+            const validationState = this.getExistingStateOrSetDefault(element);
+            this.validateAndDispatchEvent("validate", {
+                validationState,
+                elementValidatorsReference,
+            });
+        });
+    }
+    async isValid(src, root = document) {
+        /* nest inner sync function mostly because the code itself is sync
+         * (especially required by Array.every) but we still want the API to be
+         * async to future-proof it */
+        function isValidSync(src) {
+            if (!src) {
+                return false;
+            }
+            else if (Array.isArray(src)) {
+                const array = src;
+                return array.every((it) => isValidSync(it));
+            }
+            else if (typeof src === "string") {
+                return isValidSync(root.querySelector(`#${src}`));
+            }
+            else if (isValidatableFormElement(src)) {
+                return src.validity.valid;
+            }
+            else {
+                return src.querySelectorAll(":invalid").length === 0;
+            }
+        }
+        return isValidSync(src);
+    }
+    async validateElement(src) {
+        if (!src) {
+            return {
+                isValid: true,
+                isTouched: false,
+                isSubmitted: false,
+                error: null,
+            };
+        }
+        if (typeof src === "string") {
+            const element = document.getElementById(src);
+            if (!element) {
+                throw new Error(`Element with id "${src}" not found when calling validateElement(..)`);
+            }
+            src = element;
+        }
+        if (!isValidatableHTMLElement(src)) {
+            const tagName = src.tagName.toLowerCase();
+            const ref = `${tagName}#${src.id}`;
+            throw new Error(`Element "${ref}" is not a validatable element`);
+        }
+        const element = src;
+        /* Handle when element has no registered validators (and thus no event
+         * listeners) by assuming the element is valid */
+        if (!hasValidators(element)) {
+            /* For compatibility (mostly with whitebox unittests) this event is
+             * still delivered. Relying on this event is discouraged and
+             * deprecated */
+            const event = new CustomEvent("validate", {
+                bubbles: false,
+            });
+            element.dispatchEvent(event);
+            return {
+                isValid: true,
+                isTouched: false,
+                isSubmitted: false,
+                error: null,
+            };
+        }
+        return new Promise((resolve, reject) => {
+            /* Add a temporary listener, as long as IE11 is supported we cannot
+             * use "once" so instead we save the listener and remove it manually
+             * later. */
+            const once = (event) => {
+                element.removeEventListener("validity", once);
+                clearTimeout(watchdog);
+                const { touched: isTouched = false, submitted: isSubmitted = false, } = this.getState(element.id);
+                const { isValid, validationMessage } = event.detail;
+                resolve({
+                    isValid,
+                    isTouched,
+                    isSubmitted,
+                    error: isValid ? null : validationMessage,
+                });
+            };
+            element.addEventListener("validity", once);
+            /* Add a watchdog timer in case the listener isn't actually there or
+             * if the event is blocked with {@link stopPropagation} or similar. */
+            const watchdog = setTimeout(() => {
+                const tagName = element.tagName.toLowerCase();
+                const ref = `${tagName}#${element.id}`;
+                element.removeEventListener("validity", once);
+                reject(`Element "${ref}" did not respond with validity event after 500ms`);
+            }, 500);
+            /* Dispatch request to validate, this is supposed to be picked up by
+             * the the eventlistener installed while adding validators and in a
+             * happy-case this is 1:1 mapped to receiving the "validity"
+             * event. */
+            const event = new CustomEvent("validate", {
+                bubbles: false,
+            });
+            element.dispatchEvent(event);
+        });
+    }
+    async validateAllElements(root) {
+        const elements = this.getValidatableElements(root);
+        const promises = elements.map((it) => this.validateElement(it));
+        await Promise.all(promises);
+    }
+    setState(element, validationState) {
+        if (!element) {
+            return;
+        }
+        else if (typeof element === "string") {
+            const found = document.getElementById(element);
+            this.setState(found, validationState);
+        }
+        else if (!isValidatableHTMLElement(element)) {
+            const childElements = this.getValidatableElements(element);
+            for (const childElement of childElements) {
+                this.setState(childElement, validationState);
+            }
+        }
+        else {
+            const existingState = this.validationStates[element.id];
+            if (existingState) {
+                this.validationStates[element.id] = {
+                    ...existingState,
+                    ...validationState,
+                };
+            }
+            else {
+                this.validationStates[element.id] = validationState;
+            }
+        }
+    }
+    setSubmitted(element) {
+        this.setState(element, {
+            submitted: true,
+        });
+    }
+    setTouched(element) {
+        this.setState(element, {
+            touched: true,
+        });
+    }
+    setError(element, message) {
+        this.setState(element, {
+            serverError: message,
+        });
+    }
+    resetState(element) {
+        this.setState(element, {
+            touched: false,
+            submitted: false,
+            serverError: undefined,
+        });
+    }
+    getValidatableElements(parent) {
+        if (!parent) {
+            return [];
+        }
+        else if (typeof parent === "string") {
+            const element = document.getElementById(parent);
+            return this.getValidatableElements(element);
+        }
+        else {
+            const selector = ["input", "textarea", "select", "fieldset"].join(",");
+            return Array.from(parent.querySelectorAll(selector));
+        }
+    }
+    setRequiredAttribute(element, validatorConfigs) {
+        if (!validatorConfigs.required) {
+            return;
+        }
+        if (validatorConfigs.required.enabled !== false) {
+            element.dataset.required = "";
+            if (isValidatableFormElement(element)) {
+                element.setAttribute("required", "");
+            }
+        }
+        else {
+            delete element.dataset.required;
+            if (isValidatableFormElement(element)) {
+                element.removeAttribute("required");
+            }
+        }
+    }
+    useInstantValidation(foundValidators, validatorConfigs) {
+        return foundValidators.some((validator) => {
+            const config = validatorConfigs[validator.name];
+            const instantConfig = isSet(config) ? config.instant : undefined;
+            return ((validator.instant && instantConfig !== false) ||
+                instantConfig === true);
+        });
+    }
+    getState(id) {
+        return this.validationStates[id];
+    }
+    getExistingStateOrSetDefault(element) {
+        let validationState = this.getState(element.id);
+        if (!validationState) {
+            validationState = { touched: false, submitted: false };
+            this.setState(element, validationState);
+        }
+        return validationState;
+    }
+    getValidators(validatorConfigs) {
+        const validatorNames = Object.keys(validatorConfigs);
+        return validatorNames.map((validatorName) => {
+            const validator = registry[validatorName];
+            if (validator) {
+                return validator;
+            }
+            throw new Error(`Validator '${validatorName}' does not exist or is not registered, see ValidatorService.registerValidator.`);
+        });
+    }
+    getValidatorByName(name) {
+        if (!(name in registry)) {
+            throw new Error(`Validator '${name}' does not exist or is not registered, see ValidatorService.registerValidator.`);
+        }
+        return registry[name];
+    }
+    validateAndDispatchEvent(nativeEvent, params) {
+        const validationResult = this.validateAll(params.elementValidatorsReference.element, params.validationState, params.elementValidatorsReference.validators, params.elementValidatorsReference.validatorConfigs);
+        const validityMode = this.resolveValidityMode(params.elementValidatorsReference.element, params.validationState, validationResult.isValid);
+        this.dispatchValidityEvent(params.elementValidatorsReference.element, {
+            ...validationResult,
+            target: params.elementValidatorsReference.element,
+            elementId: params.elementValidatorsReference.element.id,
+            validityMode: validityMode,
+            nativeEvent,
+        });
+    }
+    resolveValidityMode(element, validationState, isValid) {
+        if (validationState.serverError) {
+            return "ERROR";
+        }
+        else if (isValid) {
+            return this.resolveValidityModeWhenValid(element);
+        }
+        else {
+            return this.resolveValidityModeWhenError(element, validationState.touched, validationState.submitted);
+        }
+    }
+    resolveValidityModeWhenValid(element) {
+        return this.hasValue(element) ? "VALID" : "INITIAL";
+    }
+    resolveValidityModeWhenError(element, touched, submitted) {
+        return submitted || this.hasValue(element) ? "ERROR" : "INITIAL";
+    }
+    hasValue(element) {
+        if (element instanceof HTMLFieldSetElement) {
+            return Array.from(element.querySelectorAll("input")).some((fieldsetInputElement) => {
+                return this.hasValue(fieldsetInputElement);
+            });
+        }
+        return Boolean(isRadiobuttonOrCheckbox(element)
+            ? element.checked
+            : element.value);
+    }
+    getValue(element) {
+        return element instanceof HTMLFieldSetElement || !element.value
+            ? ""
+            : element.value.trim();
+    }
+    validateAll(element, validationState, validators, validatorConfigs) {
+        if (validationState.serverError) {
+            return {
+                isValid: false,
+                validationMessage: validationState.serverError,
+            };
+        }
+        /* if the element is disabled we always consider it to be valid */
+        if (element.disabled) {
+            return {
+                isValid: true,
+                validationMessage: "",
+            };
+        }
+        const value = this.getValue(element);
+        const resultFromValidators = validators.map((validator) => {
+            return {
+                isValid: this.validate(value, element, validator, validatorConfigs),
+                name: validator.name,
+            };
+        });
+        const firstInvalidResult = resultFromValidators.find((result) => !result.isValid);
+        if (firstInvalidResult) {
+            const validationMessage = this.getErrorMessage(firstInvalidResult.name, validators, validatorConfigs, getElementType(element));
+            return { isValid: false, validationMessage };
+        }
+        else {
+            return { isValid: true, validationMessage: "" };
+        }
+    }
+    validate(value, element, validator, validatorConfigs) {
+        const validatorConfig = validatorConfigs[validator.name] || {};
+        const isEnabled = validatorConfig.enabled === undefined ||
+            validatorConfig.enabled === true;
+        /**
+         * Only execute validation method if enabled is undefined or true.
+         */
+        return isEnabled
+            ? validator.validation(value, element, validatorConfig)
+            : true;
+    }
+    getErrorMessage(validatorName, validators, validatorConfigs, elementType) {
+        const validatorConfig = validatorConfigs[validatorName];
+        if (validatorConfig && validatorConfig.errorMessage) {
+            return validatorConfig.errorMessage;
+        }
+        const candidates = getCandidates(validatorName, validators, elementType);
+        const key = candidates.find((candidate) => isSet(this.validationErrorMessages[candidate]));
+        if (key) {
+            return (this.validationErrorMessages[key] ?? validatorName.toUpperCase());
+        }
+        return validatorName.toUpperCase();
+    }
+    getElementsAffectedByValidity(element) {
+        if (element instanceof HTMLFieldSetElement) {
+            return this.getValidatableElements(element).filter((childElement) => childElement.closest("fieldset") === element);
+        }
+        else {
+            return [element];
+        }
+    }
+    dispatchValidityEvent(element, validityEvent) {
+        const affectedElements = this.getElementsAffectedByValidity(element);
+        const validField = validityEvent.validityMode === "ERROR";
+        const event = new CustomEvent("validity", {
+            bubbles: true,
+            detail: validityEvent,
+        });
+        for (const affectedElement of affectedElements) {
+            affectedElement.setCustomValidity(validityEvent.validationMessage);
+            affectedElement.setAttribute("aria-invalid", validField.toString());
+        }
+        element.dispatchEvent(event);
+    }
+    clearAllStates() {
+        this.validationStates = {};
+    }
+}
+/**
+ * @public
+ */
+const ValidationService = new ValidationServiceImpl();
+
+const bankAccountNumberValidator = {
+    name: "bankAccountNumber",
+    validation(value) {
+        return isEmpty(value) || isSet(parseBankAccountNumber(value));
+    },
+};
+
+const bankgiroValidator = {
+    name: "bankgiro",
+    validation(value) {
+        return isEmpty(value) || isSet(parseBankgiro(value));
+    },
+};
+
+const clearingNumberValidator = {
+    name: "clearingNumber",
+    validation(value) {
+        return isEmpty(value) || isSet(parseClearingNumber(value));
+    },
+};
+
+const dateValidator = {
+    name: "date",
+    validation(value) {
+        if (isEmpty(value)) {
+            return true;
+        }
+        const normalized = normalizeDateFormat(value);
+        if (!normalized) {
+            return false;
+        }
+        const parsed = FDate.fromIso(normalized);
+        return parsed.isValid();
+    },
+};
+const dateFormatValidator = {
+    name: "dateFormat",
+    validation(value) {
+        if (isEmpty(value)) {
+            return true;
+        }
+        const normalized = normalizeDateFormat(value);
+        return Boolean(normalized);
+    },
+};
+
+function createNumberRegexp(minDecimals = 0, maxDecimals = 2) {
+    return new RegExp(`^([-\u2212]?[0-9]+)([,.][0-9]{${minDecimals},${maxDecimals}})(?<![,.])$`);
+}
+const decimalValidator = {
+    name: "decimal",
+    validation(value, _element, config) {
+        const valueWithoutWhitespace = isSet(value)
+            ? stripWhitespace(String(value))
+            : value;
+        const minDecimalsAsNumber = isSet(config.minDecimals)
+            ? Number(config.minDecimals)
+            : undefined;
+        const maxDecimalsAsNumber = isSet(config.maxDecimals)
+            ? Number(config.maxDecimals)
+            : undefined;
+        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- technical debt, should actually verfiy value instead */
+        if (config.minDecimals && isNaN(minDecimalsAsNumber)) {
+            throw new Error("config.minDecimals must be a number");
+        }
+        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- technical debt, should actually verfiy value instead */
+        if (config.maxDecimals && isNaN(maxDecimalsAsNumber)) {
+            throw new Error("config.maxDecimals must be a number");
+        }
+        return (isEmpty(valueWithoutWhitespace) ||
+            createNumberRegexp(minDecimalsAsNumber, maxDecimalsAsNumber).test(valueWithoutWhitespace));
+    },
+};
+
+function toArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    else {
+        return [value];
+    }
+}
+const blacklistValidator = {
+    name: "blacklist",
+    validation(value, _element, config) {
+        if (!config.values) {
+            throw new Error("config.exclude must have values");
+        }
+        const values = toArray(config.values);
+        const found = values.some((it) => String(it) === value);
+        return !found;
+    },
+};
+
+const emailValidator = {
+    name: "email",
+    validation(value, _element, config) {
+        const maxLength = config.maxLength || 254;
+        const EMAIL_REGEXP = new RegExp(`^(?=.{1,${maxLength}}$)(?=.{1,64}@)[-!#$%&'*+/0-9=?A-Z^_\`a-z{|}~åäöÅÄÖ]+(\\.[-!#$%&'*+/0-9=?A-Z^_\`a-z{|}~åäöÅÄÖ]+)*@[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?(\\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$`);
+        return isEmpty(value) || EMAIL_REGEXP.test(value);
+    },
+};
+
+const NUMBER_REGEXP = /^([-−]?[0-9]+)?$/;
+const integerValidator = {
+    name: "integer",
+    validation(value) {
+        const valueWithoutWhitespace = isSet(value)
+            ? stripWhitespace(String(value))
+            : value;
+        return (isEmpty(valueWithoutWhitespace) ||
+            NUMBER_REGEXP.test(valueWithoutWhitespace));
+    },
+};
+
+/**
+ * @public
+ */
+function isInvalidDatesConfig(value) {
+    return Boolean(value.dates);
+}
+/**
+ * @public
+ */
+const invalidDatesValidator = {
+    name: "invalidDates",
+    validation(value, element, config) {
+        if (isEmpty(value)) {
+            return true;
+        }
+        if (!isInvalidDatesConfig(config)) {
+            throw new Error(`Invalid invalidDates config for ${element.id}`);
+        }
+        return !config.dates.includes(value);
+    },
+};
+
+/**
+ * @public
+ */
+function isInvalidWeekdaysConfig(value) {
+    return Boolean(value.days);
+}
+/**
+ * @public
+ */
+const invalidWeekdaysValidator = {
+    name: "invalidWeekdays",
+    validation(value, element, config) {
+        if (isEmpty(value)) {
+            return true;
+        }
+        if (!isInvalidWeekdaysConfig(config)) {
+            throw new Error(`Invalid invalidWeekdays config for ${element.id}`);
+        }
+        const day = FDate.fromIso(value).weekDay;
+        return !config.days.includes(day);
+    },
+};
+
+/**
+ * @internal
+ */
+function numberValidator$1(value, config, name, compare) {
+    if (value === "") {
+        return true;
+    }
+    const limit = config[name];
+    if (!isSet(limit)) {
+        return false;
+    }
+    const limitAsNumber = parseNumber(String(config[name]));
+    if (limitAsNumber === undefined) {
+        throw new Error(`config.${String(name)} must be a number`);
+    }
+    const valueAsNumber = parseNumber(value);
+    if (valueAsNumber === undefined) {
+        return false;
+    }
+    return compare(valueAsNumber, limitAsNumber);
+}
+
+const greaterThanValidator = {
+    name: "greaterThan",
+    validation(value, _element, config) {
+        return numberValidator$1(value, config, "limit", (value, limit) => value > limit);
+    },
+};
+
+const lessThanValidator = {
+    name: "lessThan",
+    validation(value, _element, config) {
+        return numberValidator$1(value, config, "limit", (value, limit) => value < limit);
+    },
+};
+
+const matchesValidator = {
+    name: "matches",
+    validation(value, _element, config) {
+        if (!isSet(config.id) || !isSet(value)) {
+            return true;
+        }
+        /** TODO This will crash if the element is not found */
+        /** TODO This assumes the id references an `<input>` field */
+        const el = document.getElementById(config.id);
+        return el.value === value;
+    },
+};
+
+const maxLengthValidator = {
+    name: "maxLength",
+    validation(value, _element, config) {
+        return config.length ? value.length <= config.length : true;
+    },
+};
+
+const maxValueValidator = {
+    name: "maxValue",
+    validation(value, _element, config) {
+        return numberValidator$1(value, config, this.name, (value, limit) => value <= limit);
+    },
+};
+
+const minDateValidator = {
+    name: "minDate",
+    validation(value, _element, config) {
+        if (isEmpty(value)) {
+            return true;
+        }
+        const normalizedValue = normalizeDateFormat(value);
+        if (!normalizedValue) {
+            return false;
+        }
+        const parsed = FDate.fromIso(normalizedValue);
+        const limit = FDate.fromIso(validLimit(config.limit));
+        return parsed.equals(limit) || parsed.isAfter(limit);
+    },
+};
+
+const maxDateValidator = {
+    name: "maxDate",
+    validation(value, _element, config) {
+        if (isEmpty(value)) {
+            return true;
+        }
+        const normalizedValue = normalizeDateFormat(value);
+        if (!normalizedValue) {
+            return false;
+        }
+        const parsed = FDate.fromIso(normalizedValue);
+        const limit = FDate.fromIso(validLimit(config.limit));
+        return parsed.equals(limit) || parsed.isBefore(limit);
+    },
+};
+
+const minLengthValidator = {
+    name: "minLength",
+    validation(value, _element, config) {
+        return config.length && value ? value.length >= config.length : true;
+    },
+};
+
+const minValueValidator = {
+    name: "minValue",
+    validation(value, _element, config) {
+        return numberValidator$1(value, config, this.name, (value, limit) => value >= limit);
+    },
+};
+
+const numberValidator = {
+    name: "number",
+    validation(value) {
+        return isEmpty(value) || isSet(parseNumber(value));
+    },
+};
+
+const currencyValidator = {
+    name: "currency",
+    validation(value) {
+        return isEmpty(value) || isSet(parseNumber(value));
+    },
+};
+
+const organisationsnummerValidator = {
+    name: "organisationsnummer",
+    validation(value) {
+        return isEmpty(value) || isSet(parseOrganisationsnummer(value));
+    },
+};
+
+const PERCENT_REGEXP = /^([-+]?[0-9]+)([,.][0-9]+)?$/;
+const percentValidator = {
+    name: "percent",
+    validation(value) {
+        const valueWithoutWhitespace = isSet(value)
+            ? stripWhitespace(String(value))
+            : value;
+        return (isEmpty(valueWithoutWhitespace) ||
+            PERCENT_REGEXP.test(valueWithoutWhitespace));
+    },
+};
+
+const personnummerFormatValidator = {
+    name: "personnummerFormat",
+    validation(value) {
+        return isEmpty(value) || isSet(parsePersonnummer(value));
+    },
+};
+
+const personnummerLuhnValidator = {
+    name: "personnummerLuhn",
+    validation(value) {
+        return isEmpty(value) || isSet(parsePersonnummerLuhn(value));
+    },
+};
+
+const PHONE_NUMBER_REGEXP = /^(\+?[-_/() ]*(\d[-_/() ]*?){3,17})$/;
+const phoneNumberValidator = {
+    name: "phoneNumber",
+    validation(value) {
+        if (isEmpty(value)) {
+            return true;
+        }
+        if (!isString(value) || value.length > 21) {
+            return false;
+        }
+        return PHONE_NUMBER_REGEXP.test(value);
+    },
+};
+
+const plusgiroValidator = {
+    name: "plusgiro",
+    validation(value) {
+        return isEmpty(value) || isSet(parsePlusgiro(value));
+    },
+};
+
+const postalCodeValidator = {
+    name: "postalCode",
+    validation(value) {
+        return isEmpty(value) || isSet(parsePostalCode(value));
+    },
+};
+
+const REQUIRED_REGEXP = /^\S+/;
+function isRelevantElement(input) {
+    return isRadiobuttonOrCheckbox(input) && !input.disabled;
+}
+function validateFieldset(fieldset) {
+    const inputs = Array.from(fieldset.elements).filter(isRelevantElement);
+    return inputs.length > 0 ? inputs.some((input) => input.checked) : true;
+}
+function validateChecked(element) {
+    return element.checked;
+}
+function validateInput(value) {
+    return REQUIRED_REGEXP.test(value);
+}
+const requiredValidator = {
+    name: "required",
+    validation(value, element) {
+        if (element instanceof HTMLFieldSetElement) {
+            return validateFieldset(element);
+        }
+        else if (isRadiobuttonOrCheckbox(element)) {
+            return validateChecked(element);
+        }
+        else {
+            return validateInput(value);
+        }
+    },
+};
+
+const WHITELIST_REGEXP = /^[a-zA-Z0-9 .,\-()\r\n?+=!:@*\xC0-\xFF]*$/;
+const whitelistValidator = {
+    name: "whitelist",
+    instant: true,
+    validation(value) {
+        return isEmpty(value) || WHITELIST_REGEXP.test(value);
+    },
+};
+
+ValidationService.registerValidator(bankAccountNumberValidator);
+ValidationService.registerValidator(bankgiroValidator);
+ValidationService.registerValidator(clearingNumberValidator);
+ValidationService.registerValidator(dateFormatValidator);
+ValidationService.registerValidator(dateValidator);
+ValidationService.registerValidator(decimalValidator);
+ValidationService.registerValidator(blacklistValidator);
+ValidationService.registerValidator(emailValidator);
+ValidationService.registerValidator(integerValidator);
+ValidationService.registerValidator(greaterThanValidator);
+ValidationService.registerValidator(invalidDatesValidator);
+ValidationService.registerValidator(invalidWeekdaysValidator);
+ValidationService.registerValidator(lessThanValidator);
+ValidationService.registerValidator(minLengthValidator);
+ValidationService.registerValidator(matchesValidator);
+ValidationService.registerValidator(maxLengthValidator);
+ValidationService.registerValidator(minValueValidator);
+ValidationService.registerValidator(maxValueValidator);
+ValidationService.registerValidator(minDateValidator);
+ValidationService.registerValidator(maxDateValidator);
+ValidationService.registerValidator(numberValidator);
+ValidationService.registerValidator(currencyValidator);
+ValidationService.registerValidator(organisationsnummerValidator);
+ValidationService.registerValidator(percentValidator);
+ValidationService.registerValidator(personnummerFormatValidator);
+ValidationService.registerValidator(personnummerLuhnValidator);
+ValidationService.registerValidator(phoneNumberValidator);
+ValidationService.registerValidator(plusgiroValidator);
+ValidationService.registerValidator(postalCodeValidator);
+ValidationService.registerValidator(requiredValidator);
+ValidationService.registerValidator(whitelistValidator);
+
+/**
+ * This function does nothing and should not be used.
+ *
+ * @public
+ * @deprecated This function does nothing.
+ */
+function applyValidationMessages() {
+    /* do nothing */
+}
+
+class ElementIdServiceImpl {
+    elementIdMap = new Map();
+    generateElementId(prefix = "fkui") {
+        const id = this.nextId(prefix);
+        if (document.getElementById(id) === null) {
+            return id;
+        }
+        return this.generateElementId(prefix);
+    }
+    nextId(prefix) {
+        let elementIdWithPadding = String(this.getIdFromMap(prefix));
+        while (elementIdWithPadding.length < 4) {
+            elementIdWithPadding = `0${elementIdWithPadding}`;
+        }
+        return `${prefix}-vue-element-${elementIdWithPadding}`;
+    }
+    getIdFromMap(prefix) {
+        const elementId = this.elementIdMap.get(prefix);
+        if (!elementId) {
+            this.elementIdMap.set(prefix, { count: 1 });
+            return 1;
+        }
+        elementId.count++;
+        return elementId.count;
+    }
+    reset() {
+        this.elementIdMap = new Map();
+    }
+}
+/**
+ * @public
+ */
+const ElementIdService = new ElementIdServiceImpl();
+
+/* istanbul ignore next: manually tested */
+const haveSessionStorage = (() => {
+    const test = "fkui.sessionstorage.test";
+    try {
+        if (window.sessionStorage) {
+            window.sessionStorage.setItem(test, "test");
+            window.sessionStorage.removeItem(test);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    catch {
+        /* Safari on iOS throws security exceptions when accessing
+         * sessionstorage in private browsing. */
+        return false;
+    }
+})();
+/**
+ * This feature can be used by creating a new file with something like:
+ *
+ * ```
+ * export const MyCustomPersistenceService = new PersistenceService<MyCustomApplicationModel>();
+ * ```
+ *
+ * There is also a simplified version in {@link SimplePersistenceService}.
+ *
+ * @public
+ */
+class PersistenceService {
+    cache;
+    constructor() {
+        this.cache = new Map();
+    }
+    set(key, value) {
+        if (this.isSessionPresent) {
+            window.sessionStorage.setItem(key, JSON.stringify(value));
+        }
+        this.cache.set(key, value);
+    }
+    get(key) {
+        const found = this.find(key);
+        if (typeof found !== "undefined") {
+            return found;
+        }
+        throw Error(`PersistenceService cannot find entry with key "${key}"`);
+    }
+    find(key) {
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const persisted = this.isSessionPresent
+            ? window.sessionStorage.getItem(key)
+            : null;
+        if (persisted) {
+            const value = JSON.parse(persisted);
+            this.cache.set(key, value);
+        }
+        return this.cache.get(key);
+    }
+    remove(key) {
+        if (this.isSessionPresent) {
+            window.sessionStorage.removeItem(key);
+        }
+        this.cache.delete(key);
+    }
+    /**
+     * @internal
+     */
+    /* istanbul ignore next: for mocking in unittests */
+    get isSessionPresent() {
+        return haveSessionStorage;
+    }
+}
+
+/**
+ * This feature can be used by creating a new file with something like:
+ *
+ * ```ts
+ * export const MyAwesomePersistenceService = new SimplePersistenceService<MyAwesomeModel>("my-awesome-key");
+ * ```
+ *
+ * There is also a more advanced version in {@link PersistenceService}.
+ *
+ * @public
+ */
+class SimplePersistenceService {
+    persistenceService;
+    key;
+    constructor(key) {
+        this.key = key;
+        this.persistenceService = new PersistenceService();
+    }
+    set(value) {
+        this.persistenceService.set(this.key, value);
+    }
+    get() {
+        return this.persistenceService.get(this.key);
+    }
+    find() {
+        return this.persistenceService.find(this.key);
+    }
+    remove() {
+        this.persistenceService.remove(this.key);
+    }
+}
+
+/**
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- technical debt
+class Reference {
+    ref = {};
+    constructor(ref) {
+        Object.assign(this.ref, ref);
+    }
+}
+
+/**
+ * Default delay in milliseconds for {@link waitForScreenReader}
+ *
+ * @public
+ */
+const SCREEN_READER_DELAY = 100;
+/**
+ * Defer execution of passed function to allow screen reader to update.
+ * Used if screen reader has not been updated with changed or added
+ * aria attributes before interaction.
+ *
+ * See issue:
+ * https://github.com/nvaccess/nvda/issues/12738
+ *
+ * @public
+ */
+function waitForScreenReader(callback, delay = SCREEN_READER_DELAY) {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            try {
+                const result = callback();
+                resolve(result);
+            }
+            catch (err) {
+                reject(err);
+            }
+        }, delay);
+    });
+}
+
+/**
+ * Delay before {@link alertScreenReader} text is removed.
+ *
+ * @internal
+ */
+const REMOVE_TEXT_DELAY = 2000;
+const defaultOptions = {
+    assertive: false,
+};
+let wrapper;
+/**
+ * Trigger screen reader to read the passed text.
+ *
+ * @public
+ * @param text - text to be read by screen reader.
+ * @param options - options for wrapper element attributes.
+ */
+function alertScreenReader(text, options) {
+    const mergedOptions = { ...defaultOptions, ...options };
+    const wrapper = getWrapper();
+    updateProperties(mergedOptions);
+    const msg = document.createElement("p");
+    msg.textContent = text;
+    waitForScreenReader(() => {
+        while (wrapper.firstChild) {
+            wrapper.removeChild(wrapper.firstChild);
+        }
+        wrapper.appendChild(msg);
+        setTimeout(() => {
+            // Remove element if it is still in the DOM.
+            if (msg.parentElement === wrapper) {
+                wrapper.removeChild(msg);
+            }
+        }, REMOVE_TEXT_DELAY);
+    });
+}
+/**
+ * Create an element for adding text to be read by a screen reader.
+ *
+ * @internal
+ * @param options - options for wrapper element attributes.
+ */
+function createScreenReaderWrapper(options) {
+    if (!getWrapper()) {
+        wrapper = document.createElement("div");
+        wrapper.id = "fkui-alert-screen-reader";
+        wrapper.className = "sr-only";
+        updateProperties(options);
+        document.body.appendChild(wrapper);
+    }
+}
+/**
+ * Update properties on wrapper element.
+ *
+ * @internal
+ * @param options - options for wrapper element attributes.
+ */
+function updateProperties(options) {
+    const wrapper = getWrapper();
+    const ariaLive = options.assertive ? "assertive" : "polite";
+    wrapper.setAttribute("aria-live", ariaLive);
+}
+/**
+ * Retrieve wrapper element.
+ *
+ * @internal
+ */
+function getWrapper() {
+    return wrapper;
+}
+
+if (typeof document !== "undefined") {
+    createScreenReaderWrapper({ assertive: false });
+}
+
+export { DATE_REGEXP_WITH_DASH, DecoratedError, index as DomUtils, ElementIdService, FORMAT_3_DIGITS_GROUPS, MissingValueError, POSTAL_CODE_REGEXP, PersistenceService, Reference, SCREEN_READER_DELAY, SimplePersistenceService, TranslationService, ValidationErrorMessageBuilder, ValidationService, WHITESPACE_PATTERN, addFocusListener, alertScreenReader, applyValidationMessages, configLogic, debounce, deepClone, deleteCookie, documentOrderComparator, ensureSet, findCookie, findTabbableElements, flatten, focus, focusFirst, focusLast, formatClearingNumberForBackend, formatNumber, formatPercent, formatPersonnummer, formatPostalCode, getErrorMessages, handleTab, isEmpty, isFieldset, isFocusable, isInvalidDatesConfig, isInvalidWeekdaysConfig, isRadiobuttonOrCheckbox, isSet, isString, isTabbable, isValidDate, isValidatableFormElement, isValidatableHTMLElement, isVisible, isVisibleInViewport, normalizeDateFormat, parseBankAccountNumber, parseBankgiro, parseClearingNumber, parseDate, parseNumber, parseOrganisationsnummer, parsePercent, parsePersonnummer, parsePersonnummerLuhn, parsePlusgiro, parsePostalCode, popFocus, pushFocus, removeFocusListener, restoreFocus, saveFocus, scrollTo, setCookie, stripNull, stripWhitespace, testLuhnChecksum, validChecksum, validLimit, waitForScreenReader };
+//# sourceMappingURL=index.js.map